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

erad/scenarios/utilities.py

@@ -1,76 +1,76 @@
-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
+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 +1,89 @@
-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
-                
-
-
+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("norm", [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
+                
+
+