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

erad/systems/__init__.py

@@ -0,0 +1,2 @@
+from erad.systems.hazard_system import HazardSystem
+from erad.systems.asset_system import AssetSystem

erad/systems/asset_system.py

@@ -0,0 +1,414 @@
+from collections import defaultdict, Counter
+
+from gdm.distribution.enums import PlotingStyle, MapType
+from gdm.distribution import DistributionSystem
+from shapely.geometry import Point, LineString
+import gdm.distribution.components as gdc
+from gdm.quantities import Distance
+import plotly.graph_objects as go
+from infrasys import System
+import geopandas as gpd
+import networkx as nx
+import pandas as pd
+import numpy as np
+
+
+from erad.constants import ASSET_TYPES, DEFAULT_TIME_STAMP
+from erad.gdm_mapping import asset_to_gdm_mapping
+from erad.models.asset import Asset, AssetState
+from erad.enums import AssetTypes, NodeTypes
+
+
+class AssetSystem(System):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def add_component(self, component, **kwargs):
+        assert isinstance(
+            component, ASSET_TYPES
+        ), f"Unsupported model type {component.__class__.__name__}"
+        return super().add_component(component, **kwargs)
+
+    def add_components(self, *components, **kwargs):
+        assert all(isinstance(component, ASSET_TYPES) for component in components), (
+            "Unsupported model types in passed component. Valid types are: \n"
+            + "\n".join([s.__name__ for s in ASSET_TYPES])
+        )
+        return super().add_components(*components, **kwargs)
+
+    def get_dircted_graph(self):
+        """Get the directed graph of the AssetSystem."""
+
+        graph = self.get_undirected_graph()
+        substations = list(
+            self.get_components(Asset, filter_func=lambda x: x.asset_type == AssetTypes.substation)
+        )
+
+        assert len(substations) <= 1, "There should be at most one substation in the asset system."
+
+        tree = nx.dfs_tree(graph, str(substations[0].connections[0]))
+        return tree
+
+    def get_undirected_graph(self):
+        """Get the undirected graph of the AssetSystem."""
+        g = nx.Graph()
+        graph_data = []
+        for asset in self.get_components(Asset):
+            if len(asset.connections) == 2:
+                u, v = asset.connections
+                g.add_edge(str(u), str(v), **asset.model_dump())
+            else:
+                if asset.asset_type in NodeTypes:
+                    g.add_node(str(asset.distribution_asset), **asset.model_dump())
+                else:
+                    graph_data.append(asset.model_dump())
+
+        g.graph["metadata"] = graph_data
+        return g
+
+    @classmethod
+    def from_gdm(cls, dist_system: DistributionSystem) -> "AssetSystem":
+        """Create a AssetSystem from a DistributionSystem."""
+        asset_map = AssetSystem.map_asets(dist_system)
+        # list_of_assets = AssetSystem._build_assets(asset_map)
+        system = AssetSystem(auto_add_composed_components=True)
+        list_of_assets = system._build_assets(asset_map)
+        system.add_components(*list_of_assets)
+        return system
+
+    def _add_node_data(
+        self, node_data: dict[str, list], asset: Asset, asset_state: AssetState | None = None
+    ):
+        node_data["name"].append(asset.name)
+        node_data["type"].append(asset.asset_type.name)
+        node_data["height"].append(asset.height.to("meter").magnitude)
+        node_data["elevation"].append(asset.elevation.to("meter").magnitude)
+        node_data["latitude"].append(asset.latitude)
+        node_data["longitude"].append(asset.longitude)
+        node_data["timestamp"].append(asset_state.timestamp if asset_state else DEFAULT_TIME_STAMP)
+        node_data["survival_prob"].append(asset_state.survival_probability if asset_state else 1.0)
+        node_data["wind_speed"].append(asset_state.wind_speed if asset_state else None)
+        node_data["fire_boundary_dist"].append(
+            asset_state.fire_boundary_dist if asset_state else None
+        )
+        node_data["flood_depth"].append(asset_state.flood_depth if asset_state else None)
+        node_data["flood_velocity"].append(asset_state.flood_velocity if asset_state else None)
+        node_data["peak_ground_acceleration"].append(
+            asset_state.peak_ground_acceleration if asset_state else None
+        )
+        node_data["peak_ground_velocity"].append(
+            asset_state.peak_ground_velocity if asset_state else None
+        )
+        return node_data
+
+    def _add_edge_data(
+        self, edge_data: dict[str, list], asset: Asset, asset_state: AssetState | None = None
+    ):
+        u, v = set(asset.connections)
+        buses = list(
+            self.get_components(Asset, filter_func=lambda x: x.distribution_asset in [u, v])
+        )
+        edge_data["name"].append(asset.name)
+        edge_data["type"].append(asset.asset_type.name)
+        edge_data["height"].append(asset.height.to("meter").magnitude)
+        edge_data["elevation"].append(asset.elevation.to("meter").magnitude)
+        edge_data["latitude"].append([b.latitude for b in buses])
+        edge_data["longitude"].append([b.longitude for b in buses])
+        edge_data["timestamp"].append(asset_state.timestamp if asset_state else DEFAULT_TIME_STAMP)
+        edge_data["survival_prob"].append(asset_state.survival_probability if asset_state else 1.0)
+        edge_data["wind_speed"].append(asset_state.wind_speed if asset_state else None)
+        edge_data["fire_boundary_dist"].append(
+            asset_state.fire_boundary_dist if asset_state else None
+        )
+        edge_data["flood_depth"].append(asset_state.flood_depth if asset_state else None)
+        edge_data["flood_velocity"].append(asset_state.flood_velocity if asset_state else None)
+        edge_data["peak_ground_acceleration"].append(
+            asset_state.peak_ground_acceleration if asset_state else None
+        )
+        edge_data["peak_ground_velocity"].append(
+            asset_state.peak_ground_velocity if asset_state else None
+        )
+        return edge_data
+
+    def to_gdf(self):
+        node_data = defaultdict(list)
+        edge_data = defaultdict(list)
+        assets: list[Asset] = self.get_components(Asset)
+
+        for asset in assets:
+            if len(set(asset.connections)) < 2:
+                if asset.asset_state:
+                    for asset_state in asset.asset_state:
+                        node_data = self._add_node_data(node_data, asset, asset_state)
+                else:
+                    node_data = self._add_node_data(node_data, asset, None)
+            else:
+                if asset.asset_state:
+                    for asset_state in asset.asset_state:
+                        edge_data = self._add_edge_data(edge_data, asset, asset_state)
+                else:
+                    edge_data = self._add_edge_data(edge_data, asset, None)
+
+        nodes_df = pd.DataFrame(node_data)
+        gdf_nodes = gpd.GeoDataFrame(
+            nodes_df,
+            geometry=gpd.points_from_xy(nodes_df.longitude, nodes_df.latitude),
+            crs="EPSG:4326",
+        )
+        edge_df = pd.DataFrame(edge_data)
+        edge_df = edge_df[edge_df["longitude"].apply(lambda x: len(x) == 2)]
+        geometry = [
+            LineString([Point(xy) for xy in zip(*xys)])
+            for xys in zip(edge_df["longitude"], edge_df["latitude"])
+        ]
+        gdf_edges = gpd.GeoDataFrame(edge_df, geometry=geometry, crs="EPSG:4326")
+        complete_gdf = pd.concat([gdf_nodes, gdf_edges])
+        return complete_gdf
+
+    def to_geojson(self) -> str:
+        """Create a GeoJSON from an AssetSystem."""
+        gdf_nodes = self.to_gdf()
+        return gdf_nodes.to_json()
+
+    def _prepopulate_bus_assets(
+        self,
+        asset_map: dict[AssetTypes : list[gdc.DistributionComponentBase]],
+        list_of_assets: dict[str, Asset],
+    ):
+        for asset_type, components in asset_map.items():
+            for component in components:
+                lat, long = AssetSystem._get_component_coordinate(component)
+                if isinstance(component, gdc.DistributionBus):
+                    list_of_assets[str(component.uuid)] = Asset(
+                        name=component.name,
+                        connections=[],
+                        asset_type=asset_type,
+                        distribution_asset=component.uuid,
+                        height=Distance(3, "meter"),
+                        latitude=lat,
+                        longitude=long,
+                        asset_state=[],
+                    )
+        return list_of_assets
+
+    def _build_assets(
+        self,
+        asset_map: dict[AssetTypes : list[gdc.DistributionComponentBase]],
+    ) -> list[Asset]:
+        list_of_assets: dict[str, Asset] = {}
+
+        self._prepopulate_bus_assets(asset_map, list_of_assets)
+
+        for asset_type, components in asset_map.items():
+            for component in components:
+                if not isinstance(component, gdc.DistributionBus):
+                    lat, long = AssetSystem._get_component_coordinate(component)
+                    if hasattr(component, "buses"):
+                        connections = [c.uuid for c in component.buses]
+                    elif hasattr(component, "bus"):
+                        connections = [component.bus.uuid]
+                    else:
+                        connections = []
+                    list_of_assets[str(component.uuid)] = Asset(
+                        name=component.name,
+                        connections=connections,
+                        asset_type=asset_type,
+                        distribution_asset=component.uuid,
+                        height=Distance(3, "meter"),
+                        latitude=lat,
+                        longitude=long,
+                        asset_state=[],
+                    )
+
+                    if len(connections) == 1:
+                        if str(connections[0]) in list_of_assets:
+                            asset = list_of_assets[str(connections[0])]
+                            asset.devices.append(component.uuid)
+
+        return list_of_assets.values()
+
+    @staticmethod
+    def _get_component_coordinate(component: gdc.DistributionComponentBase):
+        if hasattr(component, "buses"):
+            xs = [bus.coordinate.x for bus in component.buses]
+            ys = [bus.coordinate.y for bus in component.buses]
+            return (sum(xs) / len(xs), sum(ys) / len(ys))
+        elif hasattr(component, "bus"):
+            return (component.bus.coordinate.x, component.bus.coordinate.y)
+        elif isinstance(component, gdc.DistributionBus):
+            return (component.coordinate.x, component.coordinate.y)
+
+    @staticmethod
+    def map_asets(
+        dist_system: DistributionSystem,
+    ) -> dict[AssetTypes : list[gdc.DistributionComponentBase]]:
+        asset_dict = defaultdict(list)
+        for asset, filters in asset_to_gdm_mapping.items():
+            for filter_info in filters:
+                models = dist_system.get_components(
+                    filter_info.component_type, filter_func=filter_info.component_filter
+                )
+                asset_dict[asset].extend(list(models))
+
+        AssetSystem._maps_buses(asset_dict, dist_system)
+        AssetSystem._map_transformers(asset_dict, dist_system)
+        return asset_dict
+
+    @staticmethod
+    def _maps_buses(
+        asset_dict: dict[AssetTypes : list[gdc.DistributionComponentBase]],
+        dist_system: DistributionSystem,
+    ):
+        for bus in dist_system.get_components(gdc.DistributionBus):
+            asset_type = AssetSystem._get_bus_type(bus, asset_dict, dist_system)
+            if asset_type:
+                asset_dict[asset_type].append(bus)
+
+    @staticmethod
+    def _map_transformers(
+        asset_dict: dict[AssetTypes : list[gdc.DistributionComponentBase]],
+        dist_system: DistributionSystem,
+    ):
+        for transformer in dist_system.get_components(gdc.DistributionTransformerBase):
+            bus_types = [
+                AssetSystem._get_bus_type(b, asset_dict, dist_system) for b in transformer.buses
+            ]
+            if (
+                AssetTypes.transmission_junction_box in bus_types
+                or AssetTypes.transmission_tower in bus_types
+            ):
+                asset_dict[AssetTypes.transformer_mad_mount].append(transformer)
+            elif all(bus_type == AssetTypes.distribution_junction_box for bus_type in bus_types):
+                asset_dict[AssetTypes.transformer_mad_mount].append(transformer)
+            else:
+                asset_dict[AssetTypes.transformer_mad_mount].append(transformer)
+
+    @staticmethod
+    def _get_bus_type(
+        bus: gdc.DistributionBus,
+        asset_dict: dict[AssetTypes : list[gdc.DistributionComponentBase]],
+        dist_system: DistributionSystem,
+    ):
+        components = dist_system.get_bus_connected_components(bus.name, gdc.DistributionBranchBase)
+        connected_types = []
+        for component in components:
+            if component in asset_dict[AssetTypes.distribution_overhead_lines]:
+                connected_types.append(AssetTypes.distribution_poles)
+            elif component in asset_dict[AssetTypes.transmission_overhead_lines]:
+                connected_types.append(AssetTypes.transmission_tower)
+            elif component in asset_dict[AssetTypes.transmission_underground_cables]:
+                connected_types.append(AssetTypes.transmission_junction_box)
+            elif component in asset_dict[AssetTypes.distribution_underground_cables]:
+                connected_types.append(AssetTypes.distribution_junction_box)
+            else:
+                ...
+        if connected_types:
+            counter = Counter(connected_types)
+            return counter.most_common(1)[0][0]
+
+    def _add_node_traces(
+        self,
+        time_index: int,
+        fig: go.Figure,
+        df_ts: gpd.GeoDataFrame,
+        plotting_object: go.Scattermap | go.Scattergeo,
+    ):
+        points_only = df_ts[df_ts.geometry.geom_type == "Point"]
+        for asset_type in set(points_only["type"]):
+            print("Asset type: ", asset_type)
+            df_filt = points_only[points_only["type"] == asset_type]
+            text = [
+                "<br>".join([f"<b>{kk}:</b> {vv}" for kk, vv in rr.to_dict().items()][:-1])
+                for __, rr in df_filt.iterrows()
+            ]
+            trace = plotting_object(
+                lat=df_filt.geometry.y,
+                lon=df_filt.geometry.x,
+                mode="markers",
+                marker=dict(size=10),
+                name=asset_type,
+                hovertext=text,
+                visible=(time_index == 0),
+            )
+            fig.add_trace(trace)
+        return fig
+
+    def _add_edge_traces(
+        self,
+        time_index: int,
+        fig: go.Figure,
+        df_ts: gpd.GeoDataFrame,
+        plotting_object: go.Scattermap | go.Scattergeo,
+    ):
+        points_only = df_ts[df_ts.geometry.geom_type == "LineString"]
+        for asset_type in set(points_only["type"]):
+            df_filt = points_only[points_only["type"] == asset_type]
+            features = {k: [] for k in list(df_filt.columns) + ["text"]}
+            for _, row in df_filt.iterrows():
+                for c in df_filt.columns:
+                    features[c] = np.append(features[c], row[c])
+                features["text"] = np.append(
+                    features["text"],
+                    "<br> ".join([f"<b>{kk}:</b> {vv}" for kk, vv in row.to_dict().items()][:-1]),
+                )
+                for c in df_filt.columns:
+                    features[c] = np.append(features[c], None)
+                features["text"] = np.append(features["text"], None)
+
+            trace = plotting_object(
+                name=asset_type,
+                lat=features["latitude"],
+                lon=features["longitude"],
+                mode="lines",
+                hovertext=features["text"],
+                visible=(time_index == 0),
+            )
+            fig.add_trace(trace)
+        return fig
+
+    def plot(
+        self,
+        show: bool = True,
+        show_legend: bool = True,
+        map_type: MapType = MapType.SCATTER_MAP,
+        style: PlotingStyle = PlotingStyle.CARTO_POSITRON,
+        zoom_level: int = 11,
+    ):
+        """Plot the AssetSystem."""
+        plotting_object = getattr(go, map_type.value)
+        gdf = self.to_gdf()
+        gdf["timestamp"] = pd.to_datetime(gdf["timestamp"])
+        timestamps = sorted(gdf["timestamp"].unique())
+        fig = go.Figure()
+        steps = []
+
+        for i, ts in enumerate(timestamps):
+            df_ts = gdf[gdf["timestamp"] == ts]
+
+            fig = self._add_node_traces(i, fig, df_ts, plotting_object)
+            fig = self._add_edge_traces(i, fig, df_ts, plotting_object)
+
+            steps.append(
+                dict(
+                    method="update",
+                    label=str(ts.date()),
+                    args=[{"visible": [j == i for j in range(len(timestamps))]}],
+                )
+            )
+
+        sliders = [dict(active=0, pad={"t": 50}, steps=steps)]
+
+        fig.update_layout(
+            mapbox=dict(
+                style=style.value,
+                zoom=zoom_level,
+                # center=dict(lat=gdf.geometry.y.mean(), lon=gdf.geometry.x.mean()),
+            ),
+            sliders=sliders,
+            showlegend=True if show_legend else False,
+        )
+
+        if show:
+            fig.show()
+
+        return fig

erad/systems/hazard_system.py

@@ -0,0 +1,122 @@
+from infrasys import System
+
+from gdm.distribution.enums import PlotingStyle, MapType
+import plotly.graph_objects as go
+
+from erad.default_fragility_curves import DEFAULT_FRAGILTY_CURVES
+from erad.constants import HAZARD_MODELS
+import erad.models.fragility_curve as fc
+import erad.models.hazard as hz
+
+
+class HazardSystem(System):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def add_component(self, component, **kwargs):
+        assert isinstance(
+            component, HAZARD_MODELS
+        ), f"Unsupported model type {component.__class__.__name__}"
+        return super().add_component(component, **kwargs)
+
+    def add_components(self, *components, **kwargs):
+        assert all(isinstance(component, HAZARD_MODELS) for component in components), (
+            "Unsupported model types in passed component. Valid types are: \n"
+            + "\n".join([s.__name__ for s in HAZARD_MODELS])
+            + "\nPassed components: \n"
+            + "\n".join(set([component.__class__.__name__ for component in components]))
+        )
+        return super().add_components(*components, **kwargs)
+
+    def to_json(self, filename, overwrite=False, indent=None, data=None):
+        if not list(self.get_components(fc.HazardFragilityCurves)):
+            self.add_components(*DEFAULT_FRAGILTY_CURVES)
+        return super().to_json(filename, overwrite, indent, data)
+
+    @classmethod
+    def fire_example(cls) -> "HazardSystem":
+        hazard = hz.FireModel.example()
+        system = HazardSystem(auto_add_composed_components=True)
+        system.add_component(hazard)
+        return system
+
+    @classmethod
+    def wind_example(cls) -> "HazardSystem":
+        hazard = hz.WindModel.example()
+        system = HazardSystem(auto_add_composed_components=True)
+        system.add_component(hazard)
+        return system
+
+    @classmethod
+    def earthquake_example(cls) -> "HazardSystem":
+        hazard = hz.EarthQuakeModel.example()
+        system = HazardSystem(auto_add_composed_components=True)
+        system.add_component(hazard)
+        return system
+
+    @classmethod
+    def flood_example(cls) -> "HazardSystem":
+        hazard = hz.FloodModel.example()
+        system = HazardSystem(auto_add_composed_components=True)
+        system.add_component(hazard)
+        return system
+
+    @classmethod
+    def multihazard_example(cls) -> "HazardSystem":
+        wind_hazard = hz.WindModel.example()
+        flood_hazard = hz.FloodModel.example()
+        system = HazardSystem(auto_add_composed_components=True)
+        system.add_component(wind_hazard)
+        system.add_component(flood_hazard)
+        return system
+
+    def plot(
+        self,
+        show: bool = True,
+        show_legend: bool = True,
+        map_type: MapType = MapType.SCATTER_MAP,
+        style: PlotingStyle = PlotingStyle.CARTO_POSITRON,
+        zoom_level: int = 11,
+    ):
+        timestamps = sorted(
+            [model.timestamp for model in self.get_components(hz.BaseDisasterModel)]
+        )
+
+        fig = go.Figure()
+        steps = []
+        for i, ts in enumerate(timestamps):
+            hazards = self.get_components(
+                hz.BaseDisasterModel, filter_func=lambda x: x.timestamp == ts
+            )
+            map_obj = getattr(go, map_type.value)
+            num_traces = 0
+            for hazard in hazards:
+                num_traces += hazard.plot(i, fig, map_obj)
+            vis = [j == i for j in range(len(timestamps))]
+            result = [x for x in vis for _ in range(num_traces)]
+            steps.append(dict(method="update", label=str(ts), args=[{"visible": result}]))
+
+        sliders = [dict(active=0, pad={"t": 50}, steps=steps)]
+
+        if map_type == MapType.SCATTER_MAP:
+            fig.update_layout(
+                map={
+                    "style": style.value,
+                    "zoom": zoom_level,
+                },
+                sliders=sliders,
+                showlegend=True if show_legend else False,
+            )
+        else:
+            fig.update_layout(
+                geo=dict(
+                    projection_scale=zoom_level,
+                ),
+                sliders=sliders,
+                showlegend=True if show_legend else False,
+            )
+
+        if show:
+            fig.show()
+
+        return fig

nrel_erad-0.1.0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: NREL-erad
+Version: 0.1.0
+Summary: Graph based scalable tool for computing energy resilience metrics for distribution systems.
+Author-email: Kapil Duwadi <kapil.duwadi@nrel.gov>, Aadil Latif <aadil.altif@nrel.gov>, Kwami Sedzro <sherinann.abraham@nrel.gov>, Sherin Ann Abraham <kwami.sedzro@nrel.gov>, Bryan Palmintier <bryan.palmintier@nrel.gov>
+Maintainer-email: Aadil Latif <Aadil.Latif@nrel.gov>
+Project-URL: Homepage, https://github.com/nrel/erad
+Keywords: Distribution,Earthquake,Energy,Fire,Flooding,Power,Python,Resilience,Systems
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: grid-data-models~=2.1.3
+Requires-Dist: gdmloader
+Requires-Dist: geopandas
+Requires-Dist: requests
+Requires-Dist: shapely
+Requires-Dist: pandas
+Requires-Dist: pyhigh
+Requires-Dist: geopy
+Requires-Dist: scipy
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mkdocs; extra == "dev"
+Requires-Dist: mkdocs-jupyter; extra == "dev"
+Requires-Dist: mkdocs-material; extra == "dev"
+Requires-Dist: mkdocstrings[python]; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# ERAD (<u>E</u>nergy <u>R</u>esilience <u>A</u>nalysis for electric <u>D</u>istribution systems)
+<p align="center"> 
+<img src="docs/images/logo.svg" width="250" style="display:flex;justify-content:center;">
+<p align="center">Graph based python tool for computing energy resilience. </p>
+</p>
+
+![GitHub all releases](https://img.shields.io/github/downloads/NREL/erad/total?logo=Github&logoColor=%2300ff00&style=flat-square)
+![GitHub repo size](https://img.shields.io/github/repo-size/nrel/erad?style=flat-square)
+[![CodeFactor](https://www.codefactor.io/repository/github/nrel/erad/badge)](https://www.codefactor.io/repository/github/nrel/erad)
+[![GitHub license](https://img.shields.io/github/license/NREL/erad?style=flat-square)](https://github.com/NREL/erad/blob/main/LICENSE.txt)
+[![GitHub issues](https://img.shields.io/github/issues/NREL/erad?style=flat-square)](https://github.com/NREL/erad/issues)
+![GitHub top language](https://img.shields.io/github/languages/top/nrel/erad?style=flat-square)
+
+[Visit full documentation here.](https://nrel.github.io/erad/)
+
+Understanding the impact of disaster events on people's ability to access critical service is key to designing appropriate programs to minimize the overall impact. Flooded roads, downed power lines, flooded power substation etc. could impact access to critical services like electricity, food, health and more. The field of disaster modeling is still evolving and so is our understanding of how these events would impact our critical infrastructures such power grid, hospitals, groceries, banks etc.
+
+ERAD is a free, open-source Python toolkit for computing energy resilience measures in the face of hazards like earthquakes and flooding. It uses graph database to store data and perform computation at the household level for a variety of critical services that are connected by power distribution network. It uses asset fragility curves, which are functions that relate hazard severity to survival probability for power system assets including cables, transformers, substations, roof-mounted solar panels, etc. recommended in top literature. Programs like undergrounding, microgrid, and electricity backup units for critical infrastructures may all be evaluated using metrics and compared across different neighborhoods to assess their effects on energy resilience.
+
+ERAD is designed to be used by researchers, students, community stakeholders, distribution utilities to understand and possibly evaluate effectiveness of different post disaster programs to improve energy resilience. It was funded by National Renewable Energy Laboratory (NREL) and made publicly available with open license.

nrel_erad-0.1.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+erad/__init__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
+erad/constants.py,sha256=5WFr2OwgEvWirj5RuL0QwziSYH1p9XBnJCGard1qxjM,1621
+erad/enums.py,sha256=w4sPPIwOyjFsw9NCZy13NmH4nQWkWaDlqnP_BdNrrxI,916
+erad/gdm_mapping.py,sha256=Ur6-vJpxrRhLszJuSv7AjMotyqZ9MRlz_5MArmBE6LQ,2937
+erad/probability_builder.py,sha256=AHfdrdRrebXEKgrcBQk9ZqH7bMfTVok7sxShV_O5nu8,1370
+erad/quantities.py,sha256=Qhl-0Qorv3AbBNotnS5hfxajZgRlpf6DE1iOCg7_0DI,454
+erad/runner.py,sha256=Lvqm0YFt_E-v4SsRmVMgmnun8bU9AeDYwZB-w_dJXvk,4549
+erad/default_fragility_curves/__init__.py,sha256=TEoZ01NIb1uIAs6AF0V1NJaPBA7FcYtQ5379Frwty5M,778
+erad/default_fragility_curves/default_fire_boundary_dist.py,sha256=KX_pmJ9yyOqSavzRWk1cgkHbqyxAGmu8GCke9wh48YI,3623
+erad/default_fragility_curves/default_flood_depth.py,sha256=uy4aAKqDNfsXQq1LKYViQhPIeq0EiO8Y_i3Ow3K5p6E,4208
+erad/default_fragility_curves/default_flood_velocity.py,sha256=L0w9WH1cjounh8wHXii9DzgvvdDpe4jRs7m3AUrgPTM,4075
+erad/default_fragility_curves/default_fragility_curves.py,sha256=uGQb0WhtgCyu_rNhh9UibJLdEELD1E28iUMQsLgSUpk,996
+erad/default_fragility_curves/default_peak_ground_acceleration.py,sha256=cvjgm0jK7nEf0T8Tx0KyOyVPqnqj6GUTrKhqIIFZEK4,5695
+erad/default_fragility_curves/default_peak_ground_velocity.py,sha256=-M6EWv5sq_M2FxQfad_kwORMk0RRfQVjNzNQo2NnKJA,3887
+erad/default_fragility_curves/default_wind_speed.py,sha256=gtsNFJYcY2qA906lmFYTZDpxvfknk-kxuLgOId5-nLY,3915
+erad/models/__init__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
+erad/models/asset.py,sha256=-SUjiaB9iIINDY8a1xhSxjv5gajB7LE7JG0EtxXwhHI,11237
+erad/models/asset_mapping.py,sha256=vdqiraFo_Ssd4Se9YEne34TjW1MSCVErmLHFqJa96Nw,518
+erad/models/fragility_curve.py,sha256=9K5q_VZVEqNKSPIcmrD2uhF9ClZ7p57oKY4jtxyu9tc,3725
+erad/models/probability.py,sha256=hTVBCundyfX5NwoAyF_13osluJDWft1N2Il8XeLabfk,1933
+erad/models/hazard/__init__.py,sha256=3PacFmU_iIxZRLiIvcRCXJLUDdgHputUEnuvQvJ8VNM,295
+erad/models/hazard/base_models.py,sha256=nZndeKYIJrn_FDyDIfpfnGQiHdoXBz_mAtBn61iW4bY,423
+erad/models/hazard/common.py,sha256=FIGPD8w3hsFyK_J99Wyp2p2KsC1McmtXD4zIrtqLjYM,815
+erad/models/hazard/earthquake.py,sha256=OOKpl2g1PVOYdRIj1Gmi3F8sGc9Lhsquzs7-etrTjuI,3194
+erad/models/hazard/flood.py,sha256=ScmqKu_ChbsfHWZy5SrkVixevLOrcQPY2eGlzOaWAio,2717
+erad/models/hazard/wild_fire.py,sha256=hjlp_AI4I1P00F_p0N4pYVdTAmrBr4F4kXKvpmMGWoM,4110
+erad/models/hazard/wind.py,sha256=YNmXnxMpNWb45UwPheQqC5PCaVN8wdnLLp8jQZjMHuw,5187
+erad/systems/__init__.py,sha256=TYQ44-fJ0REaEg0I4RClxPK0BZTuvVlSEqmrh_xqTAs,102
+erad/systems/asset_system.py,sha256=MDzc0p6RE81k8ZPjzjuil5fME89Rd7fqeYlUqjNCYnw,17267
+erad/systems/hazard_system.py,sha256=dHrA4p1mnaQvBLQVIZWLhZ6NcGD3toyGElP-LW0HRX4,4305
+nrel_erad-0.1.0.dist-info/licenses/LICENSE.txt,sha256=YhE40B_XkokpkrkfYYs75IWapyRMl_Jdo__vzVWO7eY,1571
+nrel_erad-0.1.0.dist-info/METADATA,sha256=snlcuFSxtS0rJCaVkMYWwzjfGpf6EbsyfbZw3dJqFtA,4104
+nrel_erad-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nrel_erad-0.1.0.dist-info/top_level.txt,sha256=TR5AAzfVy08tAhcPCsDnwvQuVJ2oXZ334IFTb3iHj-k,5
+nrel_erad-0.1.0.dist-info/RECORD,,

{NREL_erad-0.0.0a0.dist-info → nrel_erad-0.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any