py_windblade_opa 0.6.6__py3-none-any.whl

py_windblade_opa/__init__.py

@@ -0,0 +1,19 @@
+from importlib.metadata import version as _version, PackageNotFoundError as _PackageNotFoundError
+
+try:
+    __version__ = _version("py_windblade_opa")
+except _PackageNotFoundError:
+    __version__ = "0.0.0+unknown"
+
+__np_package_name__ = 'py_windblade_opa'
+
+from .support import WECSSpecs, MiscConstants, WECSConfig
+from .airfoils.airfoil_abstract import AirfoilAC 
+from .blade_geometry import BladeGeometry
+from .blade_geometry_v2 import BladeGeometryContainer
+from .wel_blade_designer import WELBladeDesigner
+from .blade_plotter import BladePlot
+from .deol_orch.blade_calc_orchestrator import BladeCalcOrchestrator
+from .utils import x_irregular_to_xnew, x_irregular_to_linspace
+
+

py_windblade_opa/airfoils/__init__.py

@@ -0,0 +1 @@
+from .af_naca4415 import NACA4415

py_windblade_opa/airfoils/af_naca4415.py

@@ -0,0 +1,75 @@
+import numpy as np
+from .airfoil_abstract import AirfoilAC
+
+class NACA4415(AirfoilAC):
+    """ Class representing the NACA 4415 airfoil. """
+
+    def __init__(self, thickness):
+        super().__init__()
+        self.designation = "NACA4415"
+        self._t = thickness
+        self._airfoil_elastic_centre = 0.296
+        self.CLdataRe250000 = np.array([[-10, -0.43], [-9, -0.41], [-4, -0.16], [-2, 0.04], 
+            [0, 0.23], [2, 0.43], [5, 0.66], [7, 0.85], [9, 1.03],
+            [11, 1.19], [13, 1.32], [17, 1.42], [19, 1.44], [21, 1.39],
+            [25, 1.23], [30, 0.92], [35, 1.08], [40, 1.22], [45, 1.21],
+            [50, 1.17], [60, 1.02], [69, 0.75], [78, 0.43], [87, 0.11],
+            [97, -0.26], [106, -0.63]])  # Fill in the rest of the data
+        self.CDdataRe250000 = np.array([[-10.67, 0.16], [-8.75, 0.11], [-6.67, 0.03], [-4.42, 0.02], 
+            [-2.33, 0.02], [0.0, 0.02], [2.5, 0.02], [4.58, 0.03], [6.83, 0.03], 
+            [9.0, 0.04], [11.25, 0.06], [13.33, 0.08], [15.42, 0.09], [17.5, 0.13], 
+            [19.33, 0.15], [21.25, 0.19], [26.67, 0.3], [31.08, 0.53], [36.25, 0.77], 
+            [41.67, 1.04], [46.67, 1.22], [51.67, 1.4], [61.67, 1.7], [71.25, 1.87], 
+            [81.0, 2.05], [90.67, 2.07], [100.17, 2.05], [109.58, 2.02]])  # Fill in the rest of the data
+
+    def cl(self, angle_deg):
+        """ Returns the lift coefficient of the airfoil. """
+        return self._interpolate(angle_deg, self.CLdataRe250000)
+
+    def cd(self, angle_deg):
+        """ Calculates the drag coefficient. """
+        return self._interpolate(angle_deg, self.CDdataRe250000)
+
+    def _interpolate(self, angle_deg, xy_array):
+        """ Function that interpolates between a given array. """
+        no_rows = len(xy_array)
+        if angle_deg <= xy_array[0, 0]:
+            return xy_array[0, 1]
+        elif angle_deg >= xy_array[-1, 0]:
+            return xy_array[-1, 1]
+        else:
+            for i in range(no_rows):
+                if xy_array[i, 0] >= angle_deg:
+                    break
+            return xy_array[i, 1] - (xy_array[i, 0] - angle_deg) * (xy_array[i, 1] - xy_array[i - 1, 1]) / (xy_array[i, 0] - xy_array[i - 1, 0])
+
+    @staticmethod
+    def cl_approx(iattack_deg):
+        """
+        Calculates the CL (lift coefficient) for a single Iattack (angle of attack) value.
+
+        Args:
+        iattack_deg (float): Single Iattack (angle of attack) value in degrees.
+
+        Returns:
+        float: CL (lift coefficient) value for the given Iattack.
+        """
+        if iattack_deg < -65:
+            CL = iattack_deg * (-0.0373) - 3.5224
+        elif iattack_deg > 30:
+            CL = (7e-6 * iattack_deg**3 - 0.0018 * iattack_deg**2 + 0.119 * iattack_deg - 1.196)
+        elif iattack_deg > -10:
+            CL = (-7e-5 * iattack_deg**3 - 0.0004 * iattack_deg**2 + 0.0962 * iattack_deg + 0.242)
+        else:
+            CL = -0.95
+        return CL
+
+
+
+if __name__== "__main__":
+    # Example usage
+    naca4415 = NACA4415(thickness=0.15)
+    lift_coefficient = naca4415.cl(5)  # Example angle
+    drag_coefficient = naca4415.cd(5)  # Example angle
+
+# %%

py_windblade_opa/airfoils/af_naca4415_test.py

@@ -0,0 +1,78 @@
+#%%
+import numpy as np
+try:
+    from .airfoil_abstract import AirfoilAC
+except:
+    from airfoil_abstract import AirfoilAC
+    
+class NACAtest(AirfoilAC):
+    """ Class representing the test cases 
+    
+    It uses a version of the NACAtest airfoil .
+    """
+
+    def __init__(self, thickness):
+        super().__init__()
+        self.designation = "NACAtest"
+        self._t = thickness
+        self._airfoil_elastic_centre = 0.296
+        self.CLdataRe250000 = np.array([[-10, -0.43], [-9, -0.41], [-4, -0.16], [-2, 0.04], 
+            [0, 0.23], [2, 0.43], [5, 0.66], [7, 0.85], [9, 1.03],
+            [11, 1.19], [13, 1.32], [17, 1.42], [19, 1.44], [21, 1.39],
+            [25, 1.23], [30, 0.92], [35, 1.08], [40, 1.22], [45, 1.21],
+            [50, 1.17], [60, 1.02], [69, 0.75], [78, 0.43], [87, 0.11],
+            [97, -0.26], [106, -0.63]])  # Fill in the rest of the data
+        self.CDdataRe250000 = np.array([[-10.67, 0.16], [-8.75, 0.11], [-6.67, 0.03], [-4.42, 0.02], 
+            [-2.33, 0.02], [0.0, 0.02], [2.5, 0.02], [4.58, 0.03], [6.83, 0.03], 
+            [9.0, 0.04], [11.25, 0.06], [13.33, 0.08], [15.42, 0.09], [17.5, 0.13], 
+            [19.33, 0.15], [21.25, 0.19], [26.67, 0.3], [31.08, 0.53], [36.25, 0.77], 
+            [41.67, 1.04], [46.67, 1.22], [51.67, 1.4], [61.67, 1.7], [71.25, 1.87], 
+            [81.0, 2.05], [90.67, 2.07], [100.17, 2.05], [109.58, 2.02]])  # Fill in the rest of the data
+
+    def cl(self, angle_deg):
+        """ Returns the lift coefficient of the airfoil.
+        
+        Args:
+        -    angle_deg (float): Angle of attack in degrees. 
+        """
+        return NACAtest.cl_approx(angle_deg)
+
+    def cd(self, angle_deg):
+        """ Calculates the drag coefficient. """
+        # return self._interpolate(angle_deg, self.CDdataRe250000)
+        raise NotImplementedError("Method not implemented yet")
+
+
+
+    @staticmethod
+    def cl_approx(iattack_deg):
+        """
+        Calculates the CL (lift coefficient) for a single Iattack (angle of attack) value.
+
+        Args:
+        iattack_deg (float): Single Iattack (angle of attack) value in degrees.
+
+        Returns:
+        float: CL (lift coefficient) value for the given Iattack.
+        """
+        if iattack_deg < -65:
+            CL = iattack_deg * (-0.0373) - 3.5224
+        elif iattack_deg > 30:
+            CL = (7e-6 * iattack_deg**3 - 0.0018 * iattack_deg**2 + 0.119 * iattack_deg - 1.196)
+        elif iattack_deg > -10:
+            CL = (-7e-5 * iattack_deg**3 - 0.0004 * iattack_deg**2 + 0.0962 * iattack_deg + 0.242)
+        else:
+            CL = -0.95
+        return CL
+
+
+
+if __name__== "__main__":
+    # Example usage
+
+    naca4415 = NACAtest(thickness=0.15)
+    lift_coefficient = naca4415.cl(5)  # Example angle
+    print(lift_coefficient)
+    # drag_coefficient = naca4415.cd(5)  # Example angle
+
+# %%

py_windblade_opa/airfoils/airfoil_abstract.py

@@ -0,0 +1,48 @@
+#%%
+from abc import ABC, abstractmethod
+import numpy as np
+
+class AirfoilAC(ABC):
+    """ Abstract class that defines airfoil types. Only provides by default Cl, Cd. """
+
+    def __init__(self):
+        self.af_designation = ""
+        self._airfoil_elastic_centre = 0.0
+
+    @abstractmethod
+    def cl(self, pip):
+        """ Calculate the lift coefficient. """
+        pass
+
+    @abstractmethod
+    def cd(self, pip):
+        """ Calculate the drag coefficient. """
+        pass
+
+    @property
+    def designation(self)-> str: 
+        """the designation of the airfoil
+
+        Returns:
+            _type_: _description_
+        """        
+        return self.af_designation
+
+    @designation.setter
+    def designation(self, value):
+        self.af_designation = value
+
+    @property
+    def airfoil_centre(self)->float:
+        """the position of the elastic center as percentage of the chord
+
+        Returns:
+            float: _description_
+        """        
+        return self._airfoil_elastic_centre
+
+    @airfoil_centre.setter
+    def airfoil_centre(self, value):
+        self._airfoil_elastic_centre = value
+
+

py_windblade_opa/airfoils/obsolete_cl.py

@@ -0,0 +1,24 @@
+# this file contains some obsolete functions that were used in the past for the calculation of the lift coefficient (CL) for the wind turbine blade airfoil.
+# they should be removed at some point. 
+
+
+def cl_approx(iattack_deg:float) -> float:
+    """    Calculates the CL (lift coefficient) for a single Iattack (angle of attack) value.
+
+    This is probably an approximation for NACA4415 airfoil.
+
+    Args:
+    iattack_deg (float): Single Iattack (angle of attack) value in degrees.
+
+    Returns:
+    float: CL (lift coefficient) value for the given Iattack.
+    """
+    if iattack_deg < -65:
+        CL = iattack_deg * (-0.0373) - 3.5224
+    elif iattack_deg > 30:
+        CL = (7e-6 * iattack_deg**3 - 0.0018 * iattack_deg**2 + 0.119 * iattack_deg - 1.196)
+    elif iattack_deg > -10:
+        CL = (-7e-5 * iattack_deg**3 - 0.0004 * iattack_deg**2 + 0.0962 * iattack_deg + 0.242)
+    else:
+        CL = -0.95
+    return CL

py_windblade_opa/bem_hansen/__init__.py

@@ -0,0 +1,5 @@
+from .blade_aux_functions import BladeAuxFunctions
+from .aero_coefficient_interpolator import AeroCoefficientInterpolator
+from .support_functions import discretize_blade
+from .blade_performance_calculator import BladePerformanceCalculator
+from .data_models import BladeOperatingPoint

py_windblade_opa/bem_hansen/aero_coefficient_interpolator.py

@@ -0,0 +1,219 @@
+import numpy as np
+import pandas as pd
+from scipy.interpolate import griddata
+from scipy.interpolate import interp1d
+
+class AeroCoefficientInterpolator:
+    def __init__(self, df:pd.DataFrame):
+        """
+        Initialize the interpolator with a DataFrame containing aoa_deg, tcratio, C_L, C_D, and C_M.
+        
+        Parameters:
+        df (pd.DataFrame): DataFrame with columns 'aoa_deg', 'tcratio', 'C_L', 'C_D', 'C_M'.
+        """
+        self._df = df
+        # Store the points (aoa_deg and tcratio) and values (C_L, C_D, C_M) for interpolation
+        self.points = df[['aoa_deg', 'tcratio']].values  # Independent variables for interpolation
+        
+        # Store the corresponding values for interpolation
+        self.values_cl = df['C_L'].values  # Coefficient of lift
+        self.values_cd = df['C_D'].values  # Coefficient of drag
+        self.values_cm = df['C_M'].values  # Coefficient of moment
+
+    def interpolate_cl(self, aoa, tcratio, method:str="interp1d"):
+        assert method in ["interp1d", "griddata"], f"Invalid interpolation method: {method}"
+        
+        if method == "interp1d":
+            return self.interpolate_cl_interp1d(aoa, tcratio)
+        elif method == "griddata":
+            return self.interpolate_cl_gd(aoa, tcratio)
+    
+    def interpolate_cd(self, aoa, tcratio, method:str="interp1d"):
+        assert method in ["interp1d", "griddata"], f"Invalid interpolation method: {method}"
+        
+        if method == "interp1d":
+            return self.interpolate_cd_interp1d(aoa, tcratio)
+        elif method == "griddata":
+            return self.interpolate_cd_gd(aoa, tcratio)
+    
+    def interpolate_cm(self, aoa, tcratio, method:str="interp1d"):
+        assert method in ["interp1d", "griddata"], f"Invalid interpolation method: {method}"
+        
+        if method == "interp1d":
+            return self.interpolate_cm_interp1d(aoa, tcratio)
+        elif method == "griddata":
+            return self.interpolate_cm_gd(aoa, tcratio)
+            
+    #region Backwards compatible interpolation methods
+    def interpolate_cl_interp1d(self, aoa, tcratio):
+        """
+        Alternative interpolation method for coefficient of lift (C_L).
+        Interpolates for each available thickness and then for the given thickness.
+
+        Parameters:
+        aoa (float): The angle of attack for which to interpolate.
+        tcratio (float): The thickness to chord ratio for which to interpolate.
+
+        Returns:
+        float: Interpolated coefficient of lift (C_L).
+        """
+        # Code for alternative interpolation method        
+        self.cl_wide = self._df.pivot(index='aoa_deg', columns='tcratio', values='C_L')
+        self.aoa_values = self.cl_wide.index.values  # aoa_deg values (from rows)
+        self.tcratio_values = self.cl_wide.columns.values  # tcratio values (from columns)
+
+        # Step 1: Interpolate C_L values for each thickness at the given aoa (interpolating across aoa_deg)
+        clthick = np.zeros_like(self.tcratio_values)
+        for i, tcr in enumerate(self.tcratio_values):
+            # Extract C_L values for this particular tcratio
+            cl_column = self.cl_wide[tcr].values
+            
+            # Create an interpolator for aoa_deg vs C_L for the current tcratio
+            aoa_interpolator = interp1d(self.aoa_values, cl_column, kind='linear', fill_value="extrapolate")
+            
+            # Interpolate the C_L value for the given aoa
+            clthick[i] = aoa_interpolator(aoa)
+
+        # Step 2: Interpolate the resulting clthick values for the actual tcratio (interpolating across tcratio)
+        cl_interpolator = interp1d(self.tcratio_values, clthick, kind='linear', fill_value="extrapolate")
+        return cl_interpolator(tcratio)
+    
+    def interpolate_cd_interp1d(self, aoa, tcratio):
+        """Backwards compatible interpolation method for coefficient of drag (C_D).
+        
+        It uses interp1d for interpolation. This method is currently used for validation purposes (units tests and matlab).
+
+        Args:
+            aoa (_type_): _description_
+            tcratio (_type_): _description_
+
+        Returns:
+            _type_: _description_
+        """
+        self.cd_wide = self._df.pivot(index='aoa_deg', columns='tcratio', values='C_D')
+        self.aoa_values = self.cd_wide.index.values  # aoa_deg values (from rows)
+        self.tcratio_values = self.cd_wide.columns.values  # tcratio values (from columns)
+        
+        # Step1: Interpolate C_D values for each thickness at the given aoa (interpolating across aoa_deg)
+        cdthick = np.zeros_like(self.tcratio_values)
+        for i, tcr in enumerate(self.tcratio_values):
+            # Extract C_D values for this particular tcratio
+            cd_column = self.cd_wide[tcr].values
+            
+            # Create an interpolator for aoa_deg vs C_D for the current tcratio
+            aoa_interpolator = interp1d(self.aoa_values, cd_column, kind='linear', fill_value="extrapolate")
+            
+            # Interpolate the C_D value for the given aoa
+            cdthick[i] = aoa_interpolator(aoa)
+            
+        # Step 2: Interpolate the resulting cdthick values for the actual tcratio (interpolating across tcratio)
+        cd_interpolator = interp1d(self.tcratio_values, cdthick, kind='linear', fill_value="extrapolate")
+        return cd_interpolator(tcratio)
+    
+    def interpolate_cm_interp1d(self, aoa, tcratio):
+        """ 
+        Backwards compatible interpolation method for coefficient of moment (C_M).
+        
+        It uses interp1d for interpolation. This method is currently used for validation purposes (units tests and matlab).
+        
+        Args:
+            aoa (_type_): _description_
+            tcratio (_type_): _description_
+            
+        Returns:
+            float: Coefficient of moment (C_M) for the given aoa and tcratio.
+        """
+        self.cm_wide = self._df.pivot(index='aoa_deg', columns='tcratio', values='C_M')
+        self.aoa_values = self.cm_wide.index.values
+        self.tcratio_values = self.cm_wide.columns.values
+        
+        # Step1: Interpolate C_M values for each thickness at the given aoa (interpolating across aoa_deg)
+        cmthick = np.zeros_like(self.tcratio_values)
+        for i, tcr in enumerate(self.tcratio_values):
+            # Extract C_M values for this particular tcratio
+            cm_column = self.cm_wide[tcr].values
+            
+            # Create an interpolator for aoa_deg vs C_M for the current tcratio
+            aoa_interpolator = interp1d(self.aoa_values, cm_column, kind='linear', fill_value="extrapolate")
+            
+            # Interpolate the C_M value for the given aoa
+            cmthick[i] = aoa_interpolator(aoa)
+            
+        # Step 2: Interpolate the resulting cmthick values for the actual tcratio (interpolating across tcratio)
+        cm_interpolator = interp1d(self.tcratio_values, cmthick, kind='linear', fill_value="extrapolate")
+        return cm_interpolator(tcratio)
+        
+    #endregion
+
+    #region Griddata interpolation methods
+    def __interpolate(self, aoa, tcratio, values):
+        """
+        Interpolate the values for given aoa and tcratio.
+        
+        Parameters:
+        aoa (float): The angle of attack for which to interpolate.
+        tcratio (float): The thickness to chord ratio for which to interpolate.
+        values (np.array): The values to interpolate.
+        
+        Returns:
+        float: Interpolated value.
+        """
+        point_to_interpolate = np.array([[aoa, tcratio]])
+        interpolated_value = griddata(self.points, values, point_to_interpolate, method='linear')
+        return interpolated_value[0]
+
+    def interpolate_cl_gd(self, aoa, tcratio):
+        """
+        Interpolate the coefficient of lift (C_L) for given aoa and tcratio.
+        
+        This is an advanced method, however, it is not compatible with the current unit tests.
+        TODO: Develop suitable unit tests
+        
+        Parameters:
+        aoa (float): The angle of attack for which to interpolate.
+        tcratio (float): The thickness to chord ratio for which to interpolate.
+        
+        Returns:
+        float: Interpolated coefficient of lift (C_L).
+        """
+        return self.__interpolate(aoa, tcratio, self.values_cl)
+        # point_to_interpolate = np.array([[aoa, tcratio]])
+        # cl_interpolated = griddata(self.points, self.values_cl, point_to_interpolate, method='linear')
+        # return cl_interpolated[0]  # Return the interpolated value
+    
+
+    
+    def interpolate_cd_gd(self, aoa, tcratio):
+        """
+        Interpolate the coefficient of drag (C_D) for given aoa and tcratio.
+        
+        Parameters:
+        aoa (float): The angle of attack for which to interpolate.
+        tcratio (float): The thickness to chord ratio for which to interpolate.
+        
+        Returns:
+        float: Interpolated coefficient of drag (C_D).
+        """
+        # point_to_interpolate = np.array([[aoa, tcratio]])
+        # cd_interpolated = griddata(self.points, self.values_cd, point_to_interpolate, method='linear')
+        # return cd_interpolated[0]  # Return the interpolated value
+        return self.__interpolate(aoa, tcratio, self.values_cd) 
+    
+    def interpolate_cm_gd(self, aoa, tcratio):
+        """
+        Interpolate the coefficient of moment (C_M) for given aoa and tcratio.
+        
+        Parameters:
+        aoa (float): The angle of attack for which to interpolate.
+        tcratio (float): The thickness to chord ratio for which to interpolate.
+        
+        Returns:
+        float: Interpolated coefficient of moment (C_M).
+        """
+        # point_to_interpolate = np.array([[aoa, tcratio]])
+        # cm_interpolated = griddata(self.points, self.values_cm, point_to_interpolate, method='linear')
+        # return cm_interpolated[0]  # Return the interpolated value
+        return self.__interpolate(aoa, tcratio, self.values_cm)
+
+    #endregion
+