windloadpy 0.1__py3-none-any.whl → 0.1.1__py3-none-any.whl

windloadpy/__init__.py

@@ -0,0 +1,3 @@
+from .solve import calculate_velocity_pressure , calculate_gust, calculate_wall_sign_ratios, calculate_reduction_factor, interpolate_force_coefficient_for_ab , calculate_wind_force, natural_frequency
+from .mapping import get_map
+

windloadpy/mapping/__init__.py

@@ -0,0 +1 @@
+from .location import get_map 

windloadpy/mapping/location.py

@@ -0,0 +1,32 @@
+import requests
+from IPython.display import display
+from PIL import Image
+from io import BytesIO
+
+def get_map(longitude, latitude, map_style="streets-v11", zoom=12, width=600, height=400):
+    """
+    Fetches a static map image from Mapbox API.
+    
+    Parameters:
+        longitude (float): Longitude of the location.
+        latitude (float): Latitude of the location.
+        map_style (str): Mapbox map style (default: "streets-v11").
+        zoom (int): Zoom level (default: 12).
+        width (int): Width of the image in pixels (default: 600).
+        height (int): Height of the image in pixels (default: 400).
+    """
+    mapbox_access_token = "pk.eyJ1IjoiYWxiZXJ0cGFtb25hZyIsImEiOiJjbDJsa3d1M3kwb2VtM2Nwa2Vxajd1MDdsIn0.GQx5HParNf5Ba4AngkoBAw"
+    
+    url = (f"https://api.mapbox.com/styles/v1/mapbox/{map_style}/static/"
+           f"{longitude},{latitude},{zoom}/{width}x{height}"
+           f"?access_token={mapbox_access_token}")
+    
+    response = requests.get(url)
+    if response.status_code == 200:
+        image = Image.open(BytesIO(response.content))
+        display(image)
+    else:
+        print("Error fetching map image:", response.json())
+
+# Example usage
+# get_map(120.9842, 14.5995)

windloadpy/solve/__init__.py

@@ -0,0 +1,4 @@
+from .velocity import calculate_velocity_pressure
+from .gust_factor import calculate_gust
+from .natural_frequency import natural_frequency
+from .signage import calculate_wall_sign_ratios, calculate_reduction_factor, interpolate_force_coefficient_for_ab , calculate_wind_force

windloadpy/solve/gust_factor.py

@@ -0,0 +1,255 @@
+import math
+
+CONSTANTS = {
+    "B": {
+        "alpha": 7.0,
+        "zg": 356.76,
+        "a_prime": 1 / 7,
+        "b_prime": 0.84,
+        "a_bar": 1 / 4,
+        "b_bar": 0.45,
+        "c": 0.30,
+        "l": 97.54,
+        "e": 1 / 3,
+        "zmin": 9.14,
+    },
+    "C": {
+        "alpha": 9.5,
+        "zg": 274.32,
+        "a_prime": 1 / 9.5,
+        "b_prime": 1.00,
+        "a_bar": 1 / 6.5,
+        "b_bar": 0.65,
+        "c": 0.20,
+        "l": 152.40,
+        "e": 1 / 5,
+        "zmin": 4.57,
+    },
+    "D": {
+        "alpha": 11.5,
+        "zg": 213.36,
+        "a_prime": 1 / 11.5,
+        "b_prime": 1.07,
+        "a_bar": 1 / 9,
+        "b_bar": 0.80,
+        "c": 0.15,
+        "l": 198.12,
+        "e": 1 / 8,
+        "zmin": 2.13,
+    },
+}
+
+
+class calculate_gust:
+    """
+    exposure : exposure type of wind [B,C,D] 
+    wind_speed : wind speed in m/s
+    b_length : milimeters
+    l_length : milimeters   
+    """
+    def __init__(self,exposure,mean_height,wind_speed,b_length,l_length,nat_freq):
+        self.exposure = exposure
+        self.mean_height = mean_height
+        self.constants = CONSTANTS
+        self.V = wind_speed * 0.2777777778 #convert to m/s
+        self.B = b_length
+        self.L = l_length
+        self.n1 = nat_freq
+        self.type = type
+
+    def aerodynamicHeight(self):
+        zmin = self.constants[self.exposure]["zmin"]
+        z_bar = max(0.6 * self.mean_height, zmin)
+        units = ""
+        report = '''
+        \\text{ MAX}\\left( 0.6 \\times h, z_{min}\\right) <br> 
+
+        '''
+        results = {
+            "value" : z_bar,
+            "units" : units,
+            "report" : report
+        }
+        return results
+
+    def turbulenceIntensity(self):
+        c = self.constants[self.exposure]["c"]
+        Iz_bar = c * math.pow(10/self.aerodynamicHeight()['value'],1/ 6)
+        results = {
+            "value" : Iz_bar,
+            # "units" : units,
+            # "report" : report
+        }
+        return results
+
+    def scaleOfTurbulence(self):
+        l_val = self.constants[self.exposure]["l"]
+        e = self.constants[self.exposure]["e"]
+        Lz_bar = l_val * math.pow(self.aerodynamicHeight()['value']/10,e)
+        # return Lz_bar
+        results = {
+            "value" : Lz_bar,
+            # "units" : units,
+            # "report" : report
+        }
+        return results
+
+
+    def meanWindSpeed(self):
+        a_bar = self.constants[self.exposure]["a_bar"]
+        b_bar = self.constants[self.exposure]["b_bar"]
+        Vz_bar = b_bar * math.pow(self.aerodynamicHeight()['value']/10,a_bar) * self.V
+        results = {
+            "value" : Vz_bar,
+            # "units" : units,
+            # "report" : report
+        }
+        return results
+
+    def gustResponsePeakResponse(self):
+        val = 2.0 * math.log(3600.0 * self.n1)
+        gR = math.sqrt(val) + 0.577 / math.sqrt(val)
+        results = {
+            "value" : gR,
+            # "units" : units,
+            # "report" : report
+        }
+        return results
+
+    def backgroundResponse(self):
+
+        background_response_init = 1.0 + 0.63 * math.pow( (self.B + self.mean_height)/self.scaleOfTurbulence()['value'],0.63)
+        background_response = math.sqrt(1.0/background_response_init)
+        results = {
+            "value" : background_response,
+            # "units" : units,
+            # "report" : report
+        }
+        return results
+
+    def reducedFrequency(self):
+        ni = (self.n1 * self.scaleOfTurbulence()['value']) / self.meanWindSpeed()['value']
+        results = {
+            "value" : ni,
+            # "units" : units,
+            # "report" : report
+        }
+        return results
+
+    def sizeFactorEffect(self):
+        dimensions = [
+            {"name": "h", "value": self.mean_height, "constant": 4.6},
+            {"name": "B", "value": self.B, "constant": 4.6},
+            {"name": "L", "value": self.L, "constant": 15.4},
+        ]
+        R_values = {}
+
+        for dim in dimensions:
+            eta = dim["constant"] * self.n1 * (dim["value"] / self.meanWindSpeed()['value'])
+            term_exp = math.exp(-2.0 * eta)
+            Rsizefactor = (1.0 / eta) - ((1.0 / (2.0 * eta * eta)) * (1.0 - term_exp))
+            R_values[f"R{dim['name']}"] = Rsizefactor
+
+        results = {
+            "rh" : {
+                "value" : R_values['Rh'],
+                "units" : "",
+                "report" : ""
+            },
+            "rB" : {
+                "value" : R_values['RB'],
+                "units" : "",
+                "report" : ""                
+            },          
+            "rL" : {
+                "value" : R_values['RL'],
+                "units" : "",
+                "report" : ""                    
+            }
+        }
+        return results
+
+    def resonantResponseFactor(self,beta_input = 0.010):
+        '''
+        concrete structure = 0.015
+        steel = 0.010
+        '''
+        r_factor = self.sizeFactorEffect()
+
+        beta = beta_input
+        rn = (7.47 * self.reducedFrequency()["value"] ) / math.pow(1 + 10.3 * self.reducedFrequency()["value"], 5 / 3)
+
+        r_value = math.sqrt(
+                (1.0 / beta)
+                * rn
+                * r_factor["rh"]["value"]
+                * r_factor["rB"]["value"]
+                * (0.53 + 0.47 * r_factor["rL"]["value"])
+            )
+        
+        results = {
+            "rn" : {
+                "value" : rn,
+                "units" : "",
+                "report" : ""               
+            },
+            "r" : {
+                "value" : r_value,
+                "units" : "",
+                "report" : ""                   
+            }
+        }
+
+        return results
+
+    def gust_factor(self):
+        #CONSTANT
+        GQ = 3.4
+        GV = 3.4
+        COEFFICIENT = 0.925
+
+        #Factors
+        Q_factor = self.backgroundResponse()["value"]
+        gR = self.gustResponsePeakResponse()["value"]
+        R_factor = self.resonantResponseFactor()["r"]["value"]
+        Iz_bar = self.turbulenceIntensity()["value"]
+
+        if(self.n1 <= 1):
+            Gfa = (math.pow(GQ,2)*math.pow(Q_factor,2)) + (math.pow(gR,2) * math.pow(R_factor,2))
+            Gf = COEFFICIENT * ((1.0 + (1.7*Iz_bar*math.sqrt(Gfa)))/ (1.0 + (1.7*GV*Iz_bar)))
+            units = ""        
+            results = {
+                "value" : Gf,
+                "units" : units,
+                # "report" : report
+            }            
+        else:
+            numerator = 1.0 + 0.7 * GQ * self.turbulenceIntensity()['value'] * self.backgroundResponse()['value'] 
+            denominator = 1.0 + 0.7 * GV * self.turbulenceIntensity()['value']
+            gust_factor = COEFFICIENT * (numerator / denominator)
+            units = ""
+            results = {
+                "value" : gust_factor,
+                "units" : units,
+                # "report" : report
+            }
+        return results
+
+# kzt =1
+# kd = 0.85
+# wind_speed = 240
+# exposure = "D"
+# mean_height = 24.50
+# na_value = 0.90
+# # type = "rigid"
+
+# wind_velocity = calculate_gust(exposure,mean_height,wind_speed,100,100,na_value)
+# # print(wind_velocity.aerodynamicHeight())
+# # print(wind_velocity.turbulenceIntensity())
+# # print(wind_velocity.scaleOfTurbulence())
+# # print(wind_velocity.meanWindSpeed())
+# # print(wind_velocity.gustResponsePeakResponse())
+# # print(wind_velocity.backgroundResponse())
+# # # print(wind_velocity.reducedFrequency())
+# print(wind_velocity.sizeFactorEffect())
+# print(wind_velocity.gust_factor())

windloadpy/solve/header.py

@@ -0,0 +1,16 @@
+import math
+
+def radtodegree():
+    results = 180 / math.pi
+    return results
+
+def header():
+    results = """
+        <h1><center><strong>WIND CALCULATION REPORT</strong></center></h1>
+        <h2>Reference</h2>
+        <ul>
+            <li>Association of Structural Engineers of the Philippines 2015 Edition, National Structural Code of the Philippines Volume 1, Quezon City, Philippines.</li>
+            <li>American Society of Civil Engineering, ASCE 7-10, USA</li>
+            </ul>
+        """
+    return results

windloadpy/solve/natural_frequency.py

@@ -0,0 +1,31 @@
+import math
+
+def natural_frequency(material_type, mean_height):
+    report = ""
+
+    if material_type == "concrete":
+        report += "<h4>For Concrete buildings</h4>"
+        na = 14.93 / math.pow(mean_height,0.9)
+        report += f"<center> \\( n_{{ a }} = \\frac {{ 14.93 }}{{ \\text{{h}}^{{0.9}} }} \\) </center>"
+        report += f"<center> \\( n_{{a }} =  \\frac {{ 14.93 }}{{ \\left( {mean_height:.2f} \\right)^{{0.9}} }} \\) </center>"
+    elif material_type == "steel":
+        report += "<h4>For structural steel moment-resisting-frame buildings</h4>"
+        na = 8.58 / math.pow(mean_height,0.8)
+        report += f"<center> \\( n_{{ a }} = \\frac {{ 8.58 }}{{ \\text{{h}}^{{0.8}} }} \\) </center>"
+        report += f"<center> \\( n_{{ a }} = \\frac {{ 8.58 }}{{ \\left( {mean_height:.2f} \\right)^{{0.8}} }} \\) </center>"
+    elif material_type == "others":
+        na = 22.86 / mean_height
+        report += f"<center> \\( n_{{ a }} = \\frac {{ 22.86 }}{{ \\text{{h}} }} \\) </center>"
+        report += f"<center> \\( n_{{ a }} = \\frac {{ 22.86 }}{{ {mean_height:.2f} }} \\) </center>"
+
+    behavior = "rigid" if na >= 1.0 else "flexible"
+    # report += f"<center>\\( n_{{a}}  = {na:.3f} \\therefore \\text{{Structure is  {remarks}}} \\)</center>"
+ 
+    return {
+        "report": report,
+        "value": na,
+        "unit" : "hz",
+        "behavior": behavior
+    }
+
+

windloadpy/solve/signage.py

@@ -0,0 +1,126 @@
+def calculate_wall_sign_ratios(h, s, B):
+    """
+    Calculates the ratios of the vertical dimension to wall height (s/h)
+    and the horizontal dimension to vertical dimension (B/s).
+
+    :param h: The height of the wall.
+    :param s: The vertical dimension.
+    :param B: The horizontal dimension.
+    :return: A dict with keys:
+        - "clearance": s/h (rounded to 5 decimals)
+        - "aspect": B/s (rounded to 5 decimals)
+    """
+    s_over_h = s / h
+    b_over_s = B / s
+
+    return {
+        "clearance": round(s_over_h, 5),
+        "aspect": round(b_over_s, 5),
+    }
+
+def calculate_reduction_factor(epsilon):
+    """
+    Calculates the reduction factor δ = 1 - (1 - ε)^(1.5).
+
+    :param epsilon: A value between 0 and 1.
+    :return: The reduction factor (rounded to 5 decimals).
+    """
+    if epsilon < 0 or epsilon > 1:
+        raise ValueError("Epsilon (ε) must be between 0 and 1.")
+
+    delta = 1 - (1 - epsilon) ** 1.5
+    return round(delta, 5)
+
+def interpolate_force_coefficient_for_ab(aspect_ratio, clearance_ratio, delta):
+    """
+    Performs a bilinear interpolation of force coefficients (C_f) based on:
+      - aspect_ratio: (B/s)
+      - clearance_ratio: (s/h)
+      - delta: The reduction factor.
+
+    Uses pre-defined tables of aspect_ratios, clearance_ratios, and force_coefficients.
+
+    :param aspect_ratio: B/s
+    :param clearance_ratio: s/h
+    :param delta: reduction factor δ
+    :return: A dict with keys:
+        - "cfa": δ * interpolated_value (Case A)
+        - "cfb": δ * interpolated_value (Case B)
+    """
+    aspect_ratios = [0.05, 0.1, 0.2, 0.5, 1, 2, 4, 5, 10, 20, 30, 45]
+    clearance_ratios = [1, 0.9, 0.7, 0.5, 0.3, 0.2, 0.16]
+    force_coefficients = [
+        [1.80, 1.70, 1.65, 1.55, 1.45, 1.40, 1.35, 1.35, 1.30, 1.30, 1.30, 1.30],  # clearance = 1
+        [1.85, 1.75, 1.70, 1.60, 1.55, 1.50, 1.45, 1.45, 1.40, 1.40, 1.40, 1.40],  # clearance = 0.9
+        [1.90, 1.85, 1.75, 1.70, 1.65, 1.60, 1.55, 1.55, 1.55, 1.55, 1.55, 1.55],  # clearance = 0.7
+        [1.95, 1.85, 1.80, 1.75, 1.75, 1.70, 1.70, 1.70, 1.70, 1.70, 1.70, 1.75],  # clearance = 0.5
+        [1.95, 1.90, 1.85, 1.80, 1.80, 1.80, 1.80, 1.80, 1.80, 1.85, 1.85, 1.85],  # clearance = 0.3
+        [1.95, 1.90, 1.85, 1.80, 1.80, 1.80, 1.80, 1.80, 1.85, 1.90, 1.90, 1.95],  # clearance = 0.2
+        [1.95, 1.90, 1.85, 1.85, 1.80, 1.80, 1.85, 1.85, 1.85, 1.90, 1.90, 1.95],  # clearance = 0.16
+    ]
+
+    def find_indices(arr, value):
+        """
+        Finds the pair of indices in 'arr' between which 'value' lies.
+        If value is outside the range, returns the last pair of indices.
+        """
+        for i in range(len(arr) - 1):
+            if arr[i] <= value <= arr[i + 1]:
+                return i, i + 1
+        return len(arr) - 2, len(arr) - 1
+
+    # Find indices for aspect ratio
+    i1, i2 = find_indices(aspect_ratios, aspect_ratio)
+    x1, x2 = aspect_ratios[i1], aspect_ratios[i2]
+
+    # Find indices for clearance ratio
+    j1, j2 = find_indices(clearance_ratios, clearance_ratio)
+    y1, y2 = clearance_ratios[j1], clearance_ratios[j2]
+
+    # Corner values for bilinear interpolation
+    Q11 = force_coefficients[j1][i1]
+    Q12 = force_coefficients[j1][i2]
+    Q21 = force_coefficients[j2][i1]
+    Q22 = force_coefficients[j2][i2]
+
+    # Bilinear interpolation
+    denominator = (x2 - x1) * (y2 - y1)
+    # Prevent division by zero if input is outside table range in a degenerate way
+    if abs(denominator) < 1e-12:
+        interpolated_value = Q11  # fallback or handle it differently if needed
+    else:
+        interpolated_value = (
+            Q11 * (x2 - aspect_ratio) * (y2 - clearance_ratio)
+            + Q21 * (aspect_ratio - x1) * (y2 - clearance_ratio)
+            + Q12 * (x2 - aspect_ratio) * (clearance_ratio - y1)
+            + Q22 * (aspect_ratio - x1) * (clearance_ratio - y1)
+        ) / denominator
+
+    cfa = delta * interpolated_value
+    cfb = delta * interpolated_value
+
+    return {
+        "cfa": cfa,
+        "cfb": cfb,
+    }
+
+def calculate_wind_force(qh, G, CfA, As):
+    """
+    Calculates the design wind force on a pylon.
+
+    :param qh: The velocity pressure at height h.
+    :param G: The gust effect factor.
+    :param CfA: The force coefficient (Cf) as obtained from tables, etc.
+    :param As: The projected area of the structure.
+    :param load_case_type: Either "A" or "B" (or a similar descriptor).
+    :param B: Horizontal dimension (used if needed for eccentricity).
+    :return: The design wind force (float).
+    """
+    # Design wind force
+    force = qh * G * CfA * As
+
+    # If needed for case "B", you could calculate eccentricity = 0.2 * B
+    # but it does not affect the force itself in this function unless
+    # you incorporate it in further calculations.
+
+    return force

windloadpy/solve/velocity.py

@@ -0,0 +1,122 @@
+import math
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+
+class calculate_velocity_pressure:
+    def __init__(self, kzt, kd, wind_speed, exposure, mean_height):
+        self.kzt = kzt
+        self.kd = kd
+        self.wind_speed = wind_speed * 0.2777777778  # Convert to m/s
+        self.exposure = exposure
+        self.mean_height = mean_height
+        self.constants = {
+            "B": {"zg": 365.76, "alpha": 7},
+            "C": {"zg": 274.32, "alpha": 9.5},
+            "D": {"zg": 213.36, "alpha": 11.5}
+        }
+        self.zg = self.constants[exposure]["zg"]
+        self.alpha = self.constants[exposure]["alpha"]
+        self.qzkz = 0.613 * self.kzt * self.kd * self.wind_speed ** 2
+        self.height_data = [4.5, 6, 7.5, 9, 12, 15, 18, 21, 24, 27, 30, 36, 42, 48, 54, 60, 75, 90, 105, 120, 135, 150]
+        self.height_index = self._filter_height_data()
+
+    def _filter_height_data(self):
+        height_index = [index for index in self.height_data if index < self.mean_height]
+        height_index.append(self.mean_height)
+        return height_index
+    def calculate_qzkzvalue(self):
+        qzkz = 0.613 * self.kzt * self.kd * math.pow(self.wind_speed,2)
+        return qzkz
+  
+    def generate_qzkzdata(self):
+
+        height_index = []
+        kzi_arr = [] #store kzi value
+        qzi_arr = [] #store the qzi value 
+        
+        height_data = [0,4.5, 6, 7.5, 9, 12, 15, 18, 21, 24, 27, 30, 36, 42, 48, 54, 60, 75, 90, 105, 120, 135, 150]
+        for i in height_data:
+            if i < self.mean_height:
+                height_index.append(i)
+
+        height_index.append(self.mean_height)
+
+        for height in height_index:
+            alpha_power = 2 / self.alpha
+            Kz_part_one = height / self.zg
+            if height == 0:
+                Kz_part_one = 4.5 / self.zg
+                Kzi = 2.01 * math.pow(Kz_part_one,alpha_power)
+            else:
+                # Kz_part_one = 4.5 / self.zg
+                Kzi = 2.01 * math.pow(Kz_part_one,alpha_power)
+            qzi = Kzi * self.calculate_qzkzvalue()
+            kzi_arr.append(Kzi)
+            qzi_arr.append(qzi)
+        final_data = [height_index,kzi_arr,qzi_arr] 
+        return final_data
+    
+    def report(self):
+        '''
+        Generate the report using the wind velocity
+        '''
+        ##For qzkz
+        report = ""
+        report += "<h2>Velocity Pressure</h2>"
+        report += "<center> \\( q_{z } = 0.613 \\times K_{ z } \\times K_{ zt } \\times K_{ d } \\times \\left( V \\right)^{2} \\) </center>"
+        report += f"<center> \\( q_{{z}} = 0.613 \\times K_{{z}} \\times {self.kzt:.2f} \\times {self.kd:.2f} \\times \\left( {self.wind_speed:.2f} \\frac{{m}}{{s}} \\right)^{2} \\) </center>"
+        report += f"<center> \\( q_{{z}} = {self.calculate_qzkzvalue():.2f} \\times K_{{ z }} \\text{{  }} \\frac{{N}}{{m^{2}}} \\text{{ or }} P_{{a}}  \\) </center>"
+
+        return report
+
+
+    def plot(self):
+        """
+        Generate three arrays (Height, Kzi, Qzi) from self.generate_qzkzdata(),
+        and create a Matplotlib Figure without using Seaborn.
+        """
+
+        # Retrieve data
+        data = self.generate_qzkzdata()
+        ht_arr = data[0]  # Array of Heights (Y-axis)
+        qzi_arr = data[2]  # Array of Wind Velocity Pressures (X-axis)
+
+        # Create figure and axis with improved size
+        fig, ax = plt.subplots(figsize=(8, 6), dpi=150)
+
+        # Plot with improved styling
+        ax.plot(qzi_arr, ht_arr, color='black', linewidth=2.5, linestyle='-')
+
+        # Label axes and title with enhanced visibility
+        ax.set_xlabel('Wind Velocity Pressure (Pa)', fontsize=14, fontweight='bold')
+        ax.set_ylabel('Height (m)', fontsize=14, fontweight='bold')
+        ax.set_title('Wind Pressure vs. Height Profile', fontsize=16, fontweight='bold')
+
+        # Customize tick labels for readability
+        ax.tick_params(axis='both', labelsize=12)
+
+        # Set x-axis to start at 0
+        ax.set_xlim(left=0)
+
+        # Enable professional grid style
+        ax.grid(True, linestyle='--', alpha=0.6, linewidth=0.8)
+
+        # Improve layout
+        plt.tight_layout()
+
+        # Return figure for further use
+        return fig
+        # return fig
+
+
+# kzt =1
+# kd = 0.85
+# wind_speed = 240
+# exposure = "B"
+# mean_height = 24
+
+# wind_velocity = calculate_velocity_pressure(kzt,kd,wind_speed,exposure,mean_height)
+# print(wind_velocity.calculate_qzkzvalue())
+# print(wind_velocity.generate_qzkzdata())
+# print(wind_velocity.plot())

{windloadpy-0.1.dist-info → windloadpy-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: windloadpy
-Version: 0.1
+Version: 0.1.1
 Summary: This APEC internal use only for wind load calculation
 Home-page: https://github.com/albertp16/apec-py
 Author: Albert Pamonag

windloadpy-0.1.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+windloadpy/__init__.py,sha256=az3mo4y1O_p1_rXkGR3pLWtlg6RWMnIDVuZiEbofHfg,233
+windloadpy/module.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+windloadpy/mapping/__init__.py,sha256=JjIts3E5sOwHm1aXMM8x4MECeqLPkEHk5MRIhC4CUiw,30
+windloadpy/mapping/location.py,sha256=_k0381-lebZ3WCbLGP-oakwovWgyfIL6PqAcVsmthTY,1244
+windloadpy/solve/__init__.py,sha256=ueB_GBCeKNVAwQ5ce1JwKeSnkGwYGYD-Hf4Ps6itEk0,278
+windloadpy/solve/gust_factor.py,sha256=-g0A0fZA_T3KqCn1F4S0e1sBWUfoqdTLsff9a4hZEd8,7770
+windloadpy/solve/header.py,sha256=XIZNFdl8pS9HADHai4x24ERLkjIzIMjzJxLyAR0vjOY,537
+windloadpy/solve/natural_frequency.py,sha256=7S68xupzzGp6p1JVVM68dgp-RyeOebHEFPqNiMX2bUo,1423
+windloadpy/solve/signage.py,sha256=bo8dS_wZ783o0Ib_cVUt_8PvAef6Fs2u__LCrhn_740,4906
+windloadpy/solve/velocity.py,sha256=SExGJx_Gf5ZGqaoI0iMM9goCaz925msdgfePidhH7IM,4646
+windloadpy-0.1.1.dist-info/METADATA,sha256=QDthcl9o_GJwaqAUYHH24sLwNF0WKxnxvyFqMuWHu2U,482
+windloadpy-0.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+windloadpy-0.1.1.dist-info/top_level.txt,sha256=iRqSvDB0DOBDBTbTimA1ySiXGte-86P0W_4UGZDLKjM,11
+windloadpy-0.1.1.dist-info/RECORD,,

windloadpy-0.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-windloadpy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-windloadpy/module.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-windloadpy-0.1.dist-info/METADATA,sha256=8hV0gLC55TZXUKPuDn1BRawYm-ZDPRh4hedO_-NBl_4,480
-windloadpy-0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-windloadpy-0.1.dist-info/top_level.txt,sha256=iRqSvDB0DOBDBTbTimA1ySiXGte-86P0W_4UGZDLKjM,11
-windloadpy-0.1.dist-info/RECORD,,