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

erad/scenarios/flood_scenario.py

@@ -1,494 +0,0 @@
-
-from click import format_filename
-import matplotlib.pyplot as plt
-from erad.scenarios.utilities import ProbabilityFunctionBuilder, GeoUtilities
-from erad.constants import ELEVATION_RASTER_FILE, DATA_FOLDER, FLOOD_HISTORIC_SHP_PATH
-from shapely.geometry import MultiPolygon, Point, LineString, Polygon
-from erad.scenarios.abstract_scenario import BaseScenario
-from datetime import datetime, timedelta
-from scipy.optimize import curve_fit
-from scipy.spatial import Delaunay
-import geopandas as gpd
-import pandas as pd
-import numpy as np
-import stateplane
-import xmltodict
-import itertools
-import requests
-import rasterio
-import tarfile
-import time
-import sys
-import os
-
-from erad.scenarios.common import AssetTypes, asset_list
-from erad.scenarios.utilities import ProbabilityFunctionBuilder
-
-#plt.ion()
-class FlooadScenario(BaseScenario, GeoUtilities):
-    """Base class for FlooadScenario. Extends BaseScenario and GeoUtilities
-
-    Attributes:
-        origin (Point): Earthquake origin point
-        probability_model (dict): Dictionary mapping asset types to probability funcitons
-        timestamp (datetime): Scenario occurance time 
-        kwargs (dict): Additional parameters relevant for a particular scenario type      
-    """
-    
-    fragility_curves = {
-        # Electrical Grid Risk Assessment Against Flooding in Barcelona and Bristol Cities
-        AssetTypes.substation.name : ProbabilityFunctionBuilder("norm", [1.5, 0.2]),
-        AssetTypes.solar_panels.name : ProbabilityFunctionBuilder("norm", [0.04, .01]),
-        # AssetTypes.buried_lines.name : ProbabilityFunctionBuilder("norm", [80, 10]),
-        # estimated
-        AssetTypes.wind_turbines.name : ProbabilityFunctionBuilder("lognorm", [0.8, 3, 2]),
-        AssetTypes.battery_storage.name : ProbabilityFunctionBuilder("norm", [0.04, .01]),
-        # estimated
-        AssetTypes.transmission_poles.name  :  ProbabilityFunctionBuilder("lognorm", [0.8, 5, 3]),
-        # Tsunami Fragility Functions for Road and Utility Pole Assets Using Field Survey and Remotely Sensed Data from the 2018 Sulawesi Tsunami, Palu, Indonesia
-        AssetTypes.distribution_poles.name  : ProbabilityFunctionBuilder("lognorm", [1, 0.2, 1]),
-        AssetTypes.transmission_overhead_lines.name  : ProbabilityFunctionBuilder("norm", [0.04, .01]),    
-        AssetTypes.distribution_overhead_lines.name  : ProbabilityFunctionBuilder("norm", [0.04, .01]),
-    }
-    
-    
-    def __init__(self,  poly : MultiPolygon , probability_model : dict, timestamp : datetime, **kwargs) -> None:
-        super(FlooadScenario, self).__init__(poly, probability_model, timestamp, **kwargs)
-        self.kwargs = kwargs
-        self.samples = 100
-        self.use_api = True
-        
-        # self.map_elevation() 
-        if 'type' in kwargs and kwargs['type'] == 'live':
-            self.flows = pd.DataFrame()
-            self.levels = pd.DataFrame()
-            self.real_time()
-        else:
-            from shapely import wkt
-            self.flows = pd.read_csv(kwargs['file_flow'],index_col=0, parse_dates=True)
-            self.levels = pd.read_csv(kwargs['file_levels'], index_col=0, parse_dates=True)
-            df = pd.read_csv(kwargs['file_gaugues'])
-            df['geometry'] = df['geometry'].apply(wkt.loads)
-            crs = {'init': 'epsg:4326'}
-            self.gauges = gpd.GeoDataFrame(df).set_geometry('geometry')
-            #self.gauges = gpd.read_file(kwargs['file_gaugues'])
-            pass
-        # self.plot = DynamicUpdate(self.X, self.Y, self.Z, self.levels)
-        return
-    
-    @classmethod
-    def from_historical_flood_by_code(cls, flood_code : str, probability_function : dict = None):
-        data_file = os.path.join(DATA_FOLDER, FLOOD_HISTORIC_SHP_PATH)
-        assert os.path.exists(data_file), f"The data file {data_file} not found"
-        flood_data = gpd.read_file(data_file)
-        flood_data = flood_data[flood_data['DFIRM_ID'] == flood_code]
-        raise NotImplementedError("Model has not been implemented")
-        
-    def real_time(self):
-        self.gauges = self.get_flow_measurements(0)
-        self.gauges.to_csv("gauges.csv")
-        flows, levels = self.gauges_in_polygon()
-        for c in flows.columns:
-            flows[c] = flows[c].interpolate(method='polynomial', order=2)
-            levels[c] = levels[c].interpolate(method='polynomial', order=2)
-        flows = flows.ffill(axis = 0)
-        levels = levels.ffill(axis = 0)
-        flows = flows.bfill(axis = 0)
-        levels = levels.bfill(axis = 0)
-        self.flows = flows.resample("15T").interpolate()
-        self.levels = levels.resample("15T").interpolate()
-        self.flows.to_csv("flows.csv")
-        self.levels.to_csv("levels.csv")
-
-    @property
-    def valid_timepoints(self):
-        return list(self.flows.index)
-    
-    def gauges_in_polygon(self):
-        all_flows = pd.DataFrame()
-        all_levels = pd.DataFrame()
-        for idx, gauge in self.gauges.iterrows():
-            flow = pd.DataFrame()
-            level = pd.DataFrame()
-            gauge_id = gauge['GaugeLID']
-            url = f'https://water.weather.gov/ahps2/hydrograph_to_xml.php?gage={gauge_id}&output=xml'
-            response = requests.get(url)
-            #print(response.text)
-            data = xmltodict.parse(response.text)
-            times_series_data = data['site']['observed']['datum']
-            time_points = []
-            flow_points = []
-            level_points =[]
-            for data_point in times_series_data:
-                time_points.append(data_point['valid']['#text'])
-                flow_points.append(float(data_point['secondary']['#text']))
-                level_points.append(float(data_point['primary']['#text']))
-            index =pd.to_datetime(time_points)
-            flow.index =index
-            flow[gauge_id] = flow_points
-            level.index =index
-            level[gauge_id] = level_points
-            print(flow)
-            print(level)
-            all_flows = flow.merge(all_flows, right_index=True, left_index=True, how="outer")
-            all_levels = level.merge(all_levels, right_index=True, left_index=True, how="outer")
-        return all_flows, all_levels
-    
-    def get_flow_measurements(self, forecast_day: int = 0):
-        if forecast_day == 0:
-            forecast_tag = "obs"
-        else:
-            if forecast_day == 1:   
-                forecast_tag = "fcst_f024"
-            else:
-                forecast_tag = f"fcst_f{forecast_day*24}"
-                
-        url = f"https://water.weather.gov/ahps/download.php?data=tgz_{forecast_tag}"
-        r = requests.get(url, allow_redirects=True)
-        date = str(datetime.now()).replace(":", "_").replace(".", "_").replace(" ", "_")
-        shape_file_path = os.path.join(DATA_FOLDER, f'flood_shapefile_{date}.tgz')
-        open(shape_file_path, 'wb').write(r.content)
-        file_path = self.extract(shape_file_path, forecast_tag)
-        data = gpd.read_file(file_path)
-        if not data.empty:
-            water_info = []
-            for idx, row in data.iterrows():
-                point = Point(row['Latitude'], row['Longitude'])
-                if self.multipolygon.contains(point):
-                    water_info.append(row)
-            return gpd.GeoDataFrame(water_info)
-        else:
-            raise Exception("No water measurement found in selected area.")
-    
-    def extract(self, tar_url, ext):
-        extract_path = os.path.join(DATA_FOLDER, "flood_shape_file")
-        tar = tarfile.open(tar_url, 'r')
-        for item in tar:
-            tar.extract(item, extract_path)
-            if item.name.find(".tgz") != -1 or item.name.find(".tar") != -1:
-                self.extract(item.name, "./" + item.name[:item.name.rfind('/')])
-        return os.path.join(extract_path, f'national_shapefile_{ext}.shp')
-    
-    @classmethod
-    def from_live_data(
-        cls,
-        poly : MultiPolygon, 
-        probability_function : dict, 
-        startrime: datetime, 
-        duration: timedelta, 
-        timestep: timedelta
-        ):
-        kwargs = {
-            'startrime' : startrime, 
-            'duration' : duration,
-            'timestep' : timestep,
-            'type' : 'live',
-        }
-        
-        return cls(poly, probability_function, startrime, **kwargs)
-   
-    def get_elevation_by_latlong(self, lat, lon):
-        coords = ((lat,lon), (lat,lon))
-        vals = self.raster.sample(coords)
-        for val in vals:
-            elevation=val[0]
-            return 255-elevation
-
-    def map_elevation(self):
-        y_min, x_min, y_max, x_max = self.multipolygon.bounds
-        ys = np.linspace(y_min, y_max, self.samples, endpoint=True)
-        xs = np.linspace(x_min, x_max, self.samples, endpoint=True)
-        self.X, self.Y = np.meshgrid(xs, ys)
-        
-        if self.use_api:
-            self.Z = self.create_elevation_profile_using_api()
-        else:
-            self.Z = self.create_elevation_profile_using_rasterfile() 
-  
-        r, c = self.X.shape
-        for i in range(r):
-            for j in range(c):
-                x_sp, y_sp = stateplane.from_lonlat(self.X[i, j], self.Y[i, j])
-                self.X[i, j] =x_sp
-                self.Y[i, j] =y_sp
-        
-        self.min_elevation = np.min(self.Z)
-        self.max_elevation = np.max(self.Z)       
-
-        pts = np.array([self.X.flatten(), self.Y.flatten(), self.Z.flatten()]).T
-        self.volume = self.calc_polyhedron_volume(pts)
-
-        return self.X, self.Y, self.Z
-
-    def create_elevation_profile_using_rasterfile(self):
-        raster_file = os.path.join(DATA_FOLDER, ELEVATION_RASTER_FILE)
-        self.raster = rasterio.open(raster_file)
-        r, c = self.X.shape
-        self.Z = np.zeros(self.X.shape)
-        for i in range(r):
-            for j in range(c):
-                self.Z[i, j] = self.get_elevation_by_latlong(self.X[i, j], self.Y[i, j])
-        return self.Z
-    
-    def create_elevation_using_api(self, lat, lon):
-        response = requests.get(
-            f"https://api.airmap.com/elevation/v1/ele?points={lat},{lon}"
-            )
-        response = response.json()
-        if response['status'] == 'success':
-            # print(response, '--')
-            return response['data'][0] * 3.28084
-            
-        else:
-            print(response)
-        
-    def create_elevation_profile_using_api(self, X=None, Y=None):
-        coords = []
-        inputs_passed = True
-        if X is None or Y is None:
-            inputs_passed = False
-            X = self.X.flatten()
-            Y = self.Y.flatten()
-        
-        for x, y in zip(X, Y):
-            coords.extend([str(y), str(x)])
- 
-        offset = 1000
-        Z_coords = []
-        for i in range(int(len(coords)/offset) + 1):
-         
-            filt_coords = coords[i * offset: (i + 1) * offset]
-            filt_coords = ",".join(filt_coords)    
-            response = requests.get(
-            f"https://api.airmap.com/elevation/v1/ele?points={filt_coords}"
-            )
-            response = response.json()
-            if response['status'] == 'success':
-                Z_coords.extend(response['data'])
-                # print(response)
-            else:
-                print(response)
-        
-        Z = np.array(Z_coords)
-        if inputs_passed:
-            return Z
-        else:
-            Z = np.reshape(Z, self.X.shape) * 3.28084
-            return (Z)
-
-    def calc_polyhedron_volume(self, pts):
-
-        def tetrahedron_volume(a, b, c, d):
-            return np.abs(np.einsum('ij,ij->i', a-d, np.cross(b-d, c-d))) / 6
-        
-        dt = Delaunay(pts)
-        tets = dt.points[dt.simplices]
-        self.polyhedron_volume = np.sum(tetrahedron_volume(tets[:, 0], tets[:, 1], 
-                                        tets[:, 2], tets[:, 3]))
-        
-        return self.polyhedron_volume
-   
-    @property
-    def area(self) -> float:
-        """Method to calculate area of affected region."""
-        raise NotImplementedError("Method needs to be defined in derived classes")
-    
-    @property
-    def polygon(self) -> MultiPolygon:
-        """Method to return polygon for the affected region."""
-        raise NotImplementedError("Method needs to be defined in derived classes")
-        
-    @property
-    def boundary(self) -> LineString:
-        """Method to return boundary for the affected region."""
-        raise NotImplementedError("Method needs to be defined in derived classes")
-        
-    @property
-    def centroid(self) -> Point:
-        """Method to return the centroid of the affected region."""
-        return self.multipolygon.centroid
-    
-    def increment_time(self) -> dict:
-        """Method to increment simulation time for time evolviong scenarios."""
-        raise NotImplementedError("Method needs to be defined in derived classes")
-
-    def calculate_survival_probability(self, assets : dict, timestamp: datetime) -> dict:
-        """Method to calculate survival probaility of asset types.
-
-        Args:
-            assets (dict): The dictionary of all assets and their corresponding asset types
-        """
-        print('Calculating survival probaiblity ...')
-        water_elevations = []
-        coords = [
-            [],[],[]
-        ]
-        z = []
-        for idx, row in self.gauges.iterrows():
-            
-            gauge = row['GaugeLID']
-            level = self.levels[gauge][timestamp] 
-            
-            lat = row['Latitude']
-            lon = row['Longitude'] 
-            x_i, y_i = stateplane.from_lonlat(lon, lat)
-            coords[0].append(x_i)
-            coords[1].append(y_i)
-            
-            
-            if self.use_api:
-                # elevation = self.create_elevation_using_api(lat, lon)
-                # TODO: Don't know the different between level and elevation or
-                # how they relate 
-                elevation = row['Elevation_ft']
-                water_elevation = float(level) + elevation
-            else:
-                elevation = self.get_elevation_by_latlong(lat, lon)
-                water_elevation = self.get_elevation_by_latlong(lat, lon) + float(level)
-
-            self.gauges["elevation"] = elevation
-            z.append(water_elevation) #water_elevation, flow
-            coords[2].append(f"Gauge: {gauge}\nElevation: {elevation}\nWater level: {level}")
-            water_elevations.append(water_elevation)
-        self.gauges["water_level"] = water_elevations
-        
-        m = self.polyfit2d(np.array(coords[0]), np.array(coords[1]), np.array(z))
-        # self.z_ = np.zeros(self.X.shape)
-        
-        for asset_type, asset_dict in assets.items():
-            Xs = []
-            Ys = []
-            for asset, asset_data in asset_dict.items():
-                Xs.append(asset_data['coordinates'][1])
-                Ys.append(asset_data['coordinates'][0])
-                x_i, y_i = stateplane.from_lonlat(asset_data['coordinates'][1], asset_data['coordinates'][0])
-                z_i = self.polyval2d(x_i, y_i, m)
-                assets[asset_type][asset]['asset_water_level_ft'] = z_i.tolist()  #list(self.polyval2d(x_i, y_i, m))
-            
-            # if self.use_api:    
-            #     asset_elevations_ft = self.create_elevation_profile_using_api(Xs, Ys)
-            # else:
-            #     asset_elevations_ft = self.get_elevation_by_latlong(lat, lon)
-
-            i = 0
-            for asset, asset_data in asset_dict.items():
-                h =   asset_data['asset_water_level_ft'] - asset_data['elevation_ft']
-                assets[asset_type][asset]['submerge_depth_ft'] = h
-                if asset_type in self.probability_model:
-                    probability_function = self.probability_model[asset_type]
-                    failure_probability = probability_function.probability(h)
-                    assets[asset_type][asset]["survival_probability"] = 1 - failure_probability
-                else:
-                    assets[asset_type][asset]["survival_probability"] = 1
-                i+=1
-        
-        return assets
-
-    def function_to_fit(self, data, a, b, c):
-        x = data[0]
-        y = data[1]
-        return (a * x) + (y * b) + c
-    
-    def polyfit2d(self, x, y, z, order=3):
-        ncols = (order + 1)**2
-        G = np.zeros((x.size, ncols))
-        ij = itertools.product(range(order+1), range(order+1))
-        for k, (i,j) in enumerate(ij):
-            G[:,k] = x**i * y**j
-        m, _, _, _ = np.linalg.lstsq(G, z)
-        return m
-
-    def polyval2d(self, x, y, m):
-        order = int(np.sqrt(len(m))) - 1
-        ij = itertools.product(range(order+1), range(order+1))
-        z = np.zeros_like(x)
-        for a, (i,j) in zip(m, ij):
-            z += a * x**i * y**j
-        return z
-
-
-class DynamicUpdate():
-    #Suppose we know the x range
-    min_x = 0
-    max_x = 10
-
-    def __init__(self, X, Y, Z, flows):
-        self.X = X
-        self.Y = Y
-        self.Z = Z
-        self.flows = flows
-        self.min_elevation = np.min(Z)
-        self.max_elevation = np.max(Z) 
-        
-        ncontours = 15
-        step_size = (self.max_elevation - self.min_elevation) / ncontours
-        self.levels = np.arange(self.min_elevation, self.max_elevation, step_size)
-        self.fig = plt.figure()
-        self.ax1 = self.fig.add_subplot(121, projection='3d')        
-        self.ax2 = self.fig.add_subplot(222)
-        self.ax3 = self.fig.add_subplot(224)
-
-        self.ax1.plot_surface(X, Y, Z, rstride=1, cstride=1, color='0.99', antialiased=True, edgecolor='0.5')
-
-        self.ax2.contour(X, Y, Z, zdir='z', cmap='coolwarm', levels=self.levels)
-        self.flows.plot(ax = self.ax3)
-        self.fig.canvas.draw()
-        self.fig.canvas.flush_events()
-        plt.show()
-        self.fig.savefig(f"topology_0.png")
-
-
-    def update(self, water_elevations, scatter_points, water_surface, timestamp):
-        self.ax1.clear()
-        self.ax2.clear()
-        self.ax3.clear()
-        
-        X = self.X
-        Y = self.Y
-        Z = self.Z
-        
-        w = np.where(water_surface > Z, water_surface, np.nan)
-        w.flat[0] = np.nan
-        self.ax1.plot_surface(X, Y, w, rstride=1, cstride=1, color='c', antialiased=True, alpha=0.5, shade=False)
-        self.ax1.plot_surface(X, Y, Z, rstride=1, cstride=1, color='0.99', antialiased=True, edgecolor='0.5')
-        
-        self.ax2.contour(X, Y, Z, zdir='z', cmap='coolwarm', levels=self.levels)
-        self.ax2.scatter(scatter_points[0], scatter_points[1], color='red')
-        
-        for x, y, t in zip(scatter_points[0], scatter_points[1], scatter_points[2]):
-            self.ax2.text(x, y, t, fontsize=8)
-            print(t)
-        
-        self.flows.plot(ax = self.ax3)
-        self.ax3.axvline(timestamp, color="r")
-        
-        self.fig.canvas.draw()
-        self.fig.canvas.flush_events()
-        #self.fig.savefig(f"topology_{int(water_elevation)}.png")
-       
-
-if __name__ == '__main__':
-
-    
-    
-    from erad.scenarios.common import asset_list
-    
-    assets, multiploygon = asset_list(38.46, -122.95, 38.53, -122.80)  
-    flood_1 = FlooadScenario(
-        multiploygon, 
-        None, 
-        None, 
-        file_flow=r'C:\Users\alatif\Documents\GitHub\erad\erad\scenarios\flows.csv',
-        file_levels=r'C:\Users\alatif\Documents\GitHub\erad\erad\scenarios\levels.csv',
-        file_gaugues=r'C:\Users\alatif\Documents\GitHub\erad\erad\scenarios\gauges.csv',
-        )
-    timestamp = flood_1.valid_timepoints[0]
-    assets = flood_1.calculate_survival_probability(assets, timestamp)
-    print(assets)
-    # flood_1 = FlooadScenario.from_live_data(multiploygon, None, None, None, None)
-    # timestamp = flood_1.valid_timepoints[-1]
-    # for timestamp in flood_1.valid_timepoints:
-    #     assets = flood_1.calculate_survival_probability(assets, timestamp)
-    #     print(assets)
-    #     time.sleep(0.01)
-    

erad/scenarios/utilities.py

@@ -1,76 +0,0 @@
-from shapely.geometry import MultiPolygon, Point, LineString
-from shapely.ops import nearest_points
-import matplotlib.pyplot as plt
-import scipy.stats as stats
-import geopy.distance
-import numpy as np
-import stateplane
-
-
-class GeoUtilities:
-    
-    @property
-    def identify_stateplane_projection(self) -> str:
-        """ Automatically identifies stateplane projection ID  """ 
-        x = self.centroid.x
-        y = self.centroid.y
-        return stateplane.identify(x, y)
-    
-    def in_polygon(self, point : Point) -> bool:
-        return self.multipolygon.contains(point)
-
-    def distance_from_boundary(self, point : Point) -> float:
-        """ Calculates distance of a point to polygon boundary. Correct calculations require conversion to cartesian coordinates""" 
-        if self.multipolygon.contains(point):
-            p1, p2 = nearest_points(self.boundary, point)
-        else:
-            p1, p2 = nearest_points(self.multipolygon, point)    
-        coords_1 = (p1.y, p1.x)
-        coords_2 = (p2.y, p2.x)
-        return geopy.distance.geodesic(coords_1, coords_2).km    
-
-    def distance_from_centroid(self, point : Point):
-        """ Calculates distance of a point to polygon centroid. Correct calculations require conversion to cartesian coordinates """ 
-        coords_1 = (self.centroid.y, self.centroid.x)
-        coords_2 = (point.y, point.x)
-        return geopy.distance.geodesic(coords_1, coords_2).km
-    
-
-
-class ProbabilityFunctionBuilder:
-    """Class containing utility fuctions for sceario definations."""
-    
-    
-    def __init__(self, dist, params):
-        """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
-        """
-        
-        self.dist = getattr(stats, dist)
-        self.params = params
-        return 
-
-    def sample(self):
-        """Sample the distribution """
-        return self.dist.rvs(*self.params, size=1)[0]
-
-    def plot_cdf(self, x:np.linspace, ax =None, label="") -> None:
-        """Plot the cumalative distribution fuction"""
-        cdf = self.dist.cdf
-        if ax is None:
-            plt.plot(x,cdf(x, *self.params), label=label)
-        else:
-            ax.plot(x,cdf(x, *self.params), label=label)
-    
-
-    def probability(self, value: float) -> float:
-        """Calculates survival probability of a given asset.
-
-        Args:
-            value (float): value for vetor of interest. Will change with scenarions
-        """
-        cdf = self.dist.cdf
-        return cdf(value, *self.params)

erad/scenarios/wind_scenario.py

@@ -1,89 +0,0 @@
-from erad.constants import FIRE_HISTORIC_GEODATAFRAME_PATH, DATA_FOLDER
-from shapely.geometry import MultiPolygon, Point, LineString
-from erad.scenarios.utilities import ProbabilityFunctionBuilder
-from erad.scenarios.abstract_scenario import BaseScenario
-from erad.exceptions import FeatureNotImplementedError
-from erad.scenarios.utilities import GeoUtilities
-import matplotlib.pyplot as plt
-from datetime import datetime
-import geopandas as gpd
-import numpy as np
-import random
-import pyproj
-import os
-
-from erad.scenarios.common import AssetTypes
-from erad.scenarios.utilities import ProbabilityFunctionBuilder
-
-
-class WindScenario(BaseScenario, GeoUtilities): 
-    """Base class for FireScenario. Extends BaseScenario and GeoUtilities
-
-    Attributes:
-        multipolygon (MultiPolygon): MultiPolygon enclosing wild fire regions 
-        probability_model (dict): Dictionary mapping asset types to probability funcitons
-        timestamp (datetime): Scenario occurance time 
-    """
-    
-    fragility_curves = {
-        #Extending energy system modelling to include extreme weather risks and application to hurricane events in Puerto Rico
-        AssetTypes.substation.name : ProbabilityFunctionBuilder("lognorm", [0.8, 10, 5]),
-        AssetTypes.solar_panels.name :  ProbabilityFunctionBuilder("lognorm", [0.8, 10, 5]),
-        AssetTypes.buried_lines.name :  ProbabilityFunctionBuilder("lognorm", [0.8, 10, 5]),
-        AssetTypes.wind_turbines.name :  ProbabilityFunctionBuilder("normal", [0.8, 10, 5]),
-        #AssetTypes.battery_storage.name : ProbabilityFunctionBuilder("lognorm", [0.8, 10, 5]),
-        #AssetTypes.transmission_poles.name  :   ProbabilityFunctionBuilder("lognorm", [0.8, 10, 5]),
-        AssetTypes.distribution_poles.name  :  ProbabilityFunctionBuilder("lognorm", [0.8, 10, 5]),
-       # AssetTypes.transmission_overhead_lines.name  : ProbabilityFunctionBuilder("lognorm", [0.8, 10, 5]),
-        AssetTypes.distribution_overhead_lines.name  :  ProbabilityFunctionBuilder("beta", [0.8, 10, 5]),
-    }
-    
-    def __init__(self,  multipolygon : MultiPolygon , probability_model : dict, timestamp : datetime) -> None:
-        """Constructor for FireScenario.
-
-        Args:
-            multipolygon (MultiPolygon):  MultiPolygon enclosing wild fire regions 
-            probability_model (dict): Dictionary mapping asset types to probability funcitons
-            timestamp (datetime): Scenario occurance time 
-        """
-
-        super(WindScenario, self).__init__(multipolygon, probability_model, timestamp)     
-        return      
-    
-    @property
-    def area(self) -> float:
-        """Method to calculate area of affected region."""
-        geod = pyproj.Geod(ellps="WGS84")
-        area = abs(geod.geometry_area_perimeter(self.polygon)[0])
-        return area
-    
-    @property
-    def polygon(self) -> MultiPolygon:
-        """Method to return polygon for the affected region."""
-        return self.multipolygon
-        
-    @property
-    def boundary(self) -> LineString:
-        """Method to return boundary for the affected region."""
-        return self.multipolygon.boundary
-        
-    @property
-    def centroid(self) -> Point:
-        """Method to return the centroid of the affected region."""
-        return self.polygon.centroid
-            
-    def increment_time(self):
-        """Method to increment simulation time for time evolviong scenarios."""
-        raise FeatureNotImplementedError()
-
-    def calculate_survival_probability(self, assets : dict, timestamp : datetime, plot: bool) -> dict:
-        """Method to calculate survival probaility of asset types.
-
-        Args:
-            assets (dict): The dictionary of all assets and their corresponding asset types
-            plot (bool): Set to true to plot the fire survival model
-        """     
-        return assets
-                
-
-