Plot with options, __str__, flip, minor fixes

Author: mahgadalla

bladex/blade.py

@@ -5,6 +5,7 @@
 import matplotlib.pyplot as plt
 from mpl_toolkits.mplot3d import Axes3D
 
+
 class Blade(object):
     """
     Bottom-up parametrized blade construction.
@@ -185,8 +186,8 @@ def _check_params(self):
         if not (self.sections.shape == self.radii.shape ==
                 self.chord_lengths.shape == self.pitch.shape == self.rake.shape
                 == self.skew_angles.shape):
-            raise ValueError('Arrays {sections, radii, chord_lengths, pitch, \
-            rake, skew_angles} do not have the same shape.')
+            raise ValueError('Arrays {sections, radii, chord_lengths, pitch, '\
+            'rake, skew_angles} do not have the same shape.')
 
     def _compute_pitch_angle(self):
         """
@@ -244,7 +245,7 @@ def _planar_to_cylindrical(self):
                     [section.xdown_coordinates, y_section_down,
                      z_section_down]))
 
-    def apply_transformations(self, flip=True):
+    def apply_transformations(self, reflect=True):
         """
         Generate a bottom-up constructed propeller blade based on the airfoil
         transformations, see :ref:`mytransformation_operations`.
@@ -254,7 +255,7 @@ def apply_transformations(self, flip=True):
             1. Translate airfoils by reference points into origin.
 
             2. Scale X, Y coordinates by a factor of the chord length. Also
-               flip the airfoils if necessary.
+               reflect the airfoils if necessary.
 
             3. Rotate the airfoils counter-clockwise according to the local
                pitch angles. Beware of the orientation system.
@@ -268,15 +269,15 @@ def apply_transformations(self, flip=True):
                each foil on a cylinder of radius equals to the section radius,
                and the cylinder axis is the propeller axis of rotation.
 
-        :param bool flip: if true, then flip the coordinates of all the airfoils
+        :param bool reflect: if true, then reflect the coordinates of all the airfoils
             about both X-axis and Y-axis. Default value is True.
         """
         for i in range(self.n_sections):
             # Translate reference point into origin
             self.sections[i].translate(-self.sections[i].reference_point)
 
-            if flip:
-                self.sections[i].flip()
+            if reflect:
+                self.sections[i].reflect()
 
             # Scale the unit chord to actual length.
             self.sections[i].scale(self.chord_lengths[i])
@@ -286,7 +287,8 @@ def apply_transformations(self, flip=True):
             # left-handed Cartesian orientation system, where Y-axis points
             # downwards and X-axis points to the right), the standard rotation
             # matrix yields clockwise rotation.
-            self.sections[i].rotate(rad_angle=np.pi/2.0 - self.pitch_angles[i])
+            self.sections[i].rotate(
+                rad_angle=np.pi / 2.0 - self.pitch_angles[i])
 
             # Translation due to skew.
             self.sections[i].translate(
@@ -404,8 +406,9 @@ def export_ppg(self,
         output_string += 'number of sectional profiles      = ' + str(
             self.n_sections) + '\n'
         output_string += 'description of sectional profiles = BNF\n'
-        output_string += '            r/R            c/D      skew[deg]        \
-                         rake/D            P/D            t/C            f/C\n'
+        output_string += '            r/R            c/D      skew[deg]'\
+                         '         rake/D            P/D            t/C'\
+                         '            f/C\n'
         for i in range(self.n_sections):
             output_string += ' ' + str("%.8e" % self.radii[i]) + ' ' + str(
                 "%.8e" % self.chord_lengths[i]) + ' ' + str(
@@ -451,3 +454,25 @@ def export_ppg(self,
         if params_normalized is False:
             # Revert back normalized parameters into actual values.
             self._norm_to_abs(D_prop=D_prop)
+
+    def __str__(self):
+        """
+        This method prints all the parameters on the screen. Its purpose is
+        for debugging.
+        """
+        string = ''
+        string += 'Blade number of sections = {}\n'.format(self.n_sections)
+        string += '\nBlade radii sections = {}\n'.format(self.radii)
+        string += '\nChord lengths of the blade sectional profiles'\
+                  ' = {}\n'.format(self.chord_lengths)
+        string += '\nRadial distribution of the blade pitch (in unit lengths)'\
+                  ' = {}\n'.format(self.pitch)
+        string += '\nRadial distribution of the blade rake (in unit length)'\
+                  ' = {}\n'.format(self.rake)
+        string += '\nRadial distribution of the blade skew angles'\
+                  ' (in degrees) = {}\n'.format(self.skew_angles)
+        string += '\nComputed pitch angles (in radians) for the blade'\
+                  ' sections = {}\n'.format(self.pitch_angles)
+        string += '\nComputed induced rake from skew (in unit length),'\
+                  ' for the blade sections = {}\n'.format(self.induced_rake)
+        return string

bladex/profilebase.py

@@ -58,12 +58,13 @@ def _update_edges(self):
         trailing edge, hence both the leading and the trailing edges are always
         unique.
         """
-        if self.xup_coordinates[0] != self.xdown_coordinates[0]:
-            raise ValueError('Airfoils must have xup_coordinates[0] \
-                            == xdown_coordinates[0]')
-        if self.xup_coordinates[-1] != self.xdown_coordinates[-1]:
-            raise ValueError('Airfoils must have xup_coordinates[-1] \
-                                == xdown_coordinates[-1]')
+        if np.fabs(self.xup_coordinates[0] - self.xdown_coordinates[0]) > 1e-4:
+            raise ValueError('Airfoils must have xup_coordinates[0] '\
+                            'almost equal to xdown_coordinates[0]')
+        if np.fabs(
+                self.xup_coordinates[-1] - self.xdown_coordinates[-1]) > 1e-4:
+            raise ValueError('Airfoils must have xup_coordinates[-1] '\
+                             'almost equal to xdown_coordinates[-1]')
 
         self.leading_edge[0] = self.xup_coordinates[0]
         self.leading_edge[1] = self.yup_coordinates[0]
@@ -153,7 +154,7 @@ def compute_chord_line(self, n_interpolated_points=None):
         aratio = ((self.trailing_edge[1] - self.leading_edge[1]) /
                   (self.trailing_edge[0] - self.leading_edge[0]))
         if not (self.xup_coordinates == self.xdown_coordinates
-               ).all() and n_interpolated_points is None:
+                ).all() and n_interpolated_points is None:
             # If x_up != x_down element-wise, then the corresponding y_up and
             # y_down can not be comparable, hence a uniform interpolation is
             # required. Also in case the interpolated_points is None,
@@ -196,7 +197,7 @@ def compute_camber_line(self, n_interpolated_points=None):
         inaccurate measurements for obtaining the camber line.
         """
         if not (self.xup_coordinates == self.xdown_coordinates
-               ).all() and n_interpolated_points is None:
+                ).all() and n_interpolated_points is None:
             # If x_up != x_down element-wise, then the corresponding y_up and
             # y_down can not be comparable, hence a uniform interpolation is
             # required. Also in case the interpolated_points is None,
@@ -222,8 +223,8 @@ def deform_camber_line(self, percent_change, n_interpolated_points=None):
         The percentage of change is defined as follows:
 
         .. math::
-            \\frac{new magnitude of max camber - old magnitude of maximum \
-            camber}{old magnitude of maximum camber} * 100
+            \\frac{\\text{new magnitude of max camber - old magnitude of maximum \
+            camber}}{\\text{old magnitude of maximum camber}} * 100
 
         A positive percentage means the new camber is larger than the max
         camber value, while a negative percentage indicates the new value
@@ -253,7 +254,7 @@ def deform_camber_line(self, percent_change, n_interpolated_points=None):
         self.camber_line[1] *= scaling_factor
 
         if not (self.xup_coordinates == self.xdown_coordinates
-               ).all() and n_interpolated_points is None:
+                ).all() and n_interpolated_points is None:
             # If x_up != x_down element-wise, then the corresponding y_up and
             # y_down can not be comparable, hence a uniform interpolation is
             # required. Also in case the interpolated_points is None,
@@ -265,7 +266,7 @@ def deform_camber_line(self, percent_change, n_interpolated_points=None):
         if n_interpolated_points:
             (self.xup_coordinates, self.xdown_coordinates, self.yup_coordinates,
              self.ydown_coordinates
-            ) = self.interpolate_coordinates(num=n_interpolated_points)
+             ) = self.interpolate_coordinates(num=n_interpolated_points)
 
         half_thickness = 0.5 * np.fabs(
             self.yup_coordinates - self.ydown_coordinates)
@@ -276,7 +277,7 @@ def deform_camber_line(self, percent_change, n_interpolated_points=None):
     @property
     def reference_point(self):
         """
-        Return the coordinates of the airfoil's geometric center.
+        Return the coordinates of the chord's mid point.
 
         :return: reference point in 2D
         :rtype: numpy.ndarray
@@ -338,7 +339,7 @@ def max_thickness(self, n_interpolated_points=None):
         :rtype: float
         """
         if not (self.xup_coordinates == self.xdown_coordinates
-               ).all() and n_interpolated_points is None:
+                ).all() and n_interpolated_points is None:
             # If x_up != x_down element-wise, then the corresponding y_up and
             # y_down can not be comparable, hence a uniform interpolation is
             # required. Also in case the interpolated_points is None,
@@ -408,15 +409,23 @@ def rotate(self, rad_angle=None, deg_angle=None):
 
         .. math::
              \\left(\\begin{matrix} cos (\\theta) & - sin (\\theta) \\
+
             sin (\\theta) & cos (\\theta) \\end{matrix}\\right)
 
-        Given the coordinates of point
-        :math:`(P) = \\left(\\begin{matrix} x \\ y \\end{matrix}\\right)`,
-        the rotated coordinates will be:
+        Given the coordinates of point :math:`P` such that
 
         .. math::
-            P^{'} = \\left(\\begin{matrix} x^{'} \\ y^{'} \\end{matrix}\\right)
-                  = R (\\theta) \\cdot P`
+            (P) = \\left(\\begin{matrix} x \\
+
+            y \\end{matrix}\\right),
+
+        Then, the rotated coordinates will be:
+
+        .. math::
+            P^{'} = \\left(\\begin{matrix} x^{'} \\
+
+                     y^{'} \\end{matrix}\\right)
+                  = R (\\theta) \\cdot P
 
         If a standard right-handed Cartesian coordinate system is used, with
         the X-axis to the right and the Y-axis up, the rotation
@@ -431,8 +440,8 @@ def rotate(self, rad_angle=None, deg_angle=None):
         """
         if rad_angle is not None and deg_angle is not None:
             raise ValueError(
-                'You have to pass either the angle in radians or in degrees, \
-                not both.')
+                'You have to pass either the angle in radians or in degrees,' \
+                ' not both.')
         if rad_angle:
             cosine = np.cos(rad_angle)
             sine = np.sin(rad_angle)
@@ -475,9 +484,13 @@ def translate(self, translation):
         self.yup_coordinates += translation[1]
         self.ydown_coordinates += translation[1]
 
-    def flip(self):
+    def reflect(self):
         """
-        Flip the airfoil coordinates about both the X-axis and the Y-axis.
+        Reflect the airfoil coordinates about the origin, i.e. a mirror
+        transformation is performed about both the X-axis and the Y-axis.
+
+        We note that if the foil is cenetered by its reference point at the
+        origin, then the reflection is just a simple flip.
         """
         self.xup_coordinates *= -1
         self.xdown_coordinates *= -1
@@ -504,21 +517,59 @@ def scale(self, factor):
         self.ydown_coordinates *= factor
         self.translate(ref_point)
 
-    def plot(self, outfile=None):
+    def plot(self,
+             profile=True,
+             chord_line=False,
+             camber_line=False,
+             ref_point=False,
+             outfile=None):
         """
         Plot the airfoil coordinates.
 
-        :param string outfile: outfile name. If a string is provided then the
+        :param bool profile: if True, then plot the profile coordinates.
+            Default value is True
+        :param bool chord_line: if True, then plot the chord line. Default
+            value is False
+        :param bool camber_line: if True, then plot the camber line. Default
+            value is False
+        :param bool ref_point: if True, then scatter plot the reference point.
+            Default value is False
+        :param str outfile: outfile name. If a string is provided then the
             plot is saved with that name, otherwise the plot is not saved.
             Default value is None
         """
         plt.figure()
-        plt.plot(self.xup_coordinates, self.yup_coordinates)
-        plt.plot(self.xdown_coordinates, self.ydown_coordinates)
+
+        if (self.xup_coordinates is None or self.yup_coordinates is None
+                or self.xdown_coordinates is None
+                or self.ydown_coordinates is None):
+            raise ValueError('One or all the coordinates have None value.')
+
+        if profile:
+            plt.plot(self.xup_coordinates, self.yup_coordinates)
+            plt.plot(self.xdown_coordinates, self.ydown_coordinates)
+
+        if chord_line:
+            if self.chord_line is None:
+                raise ValueError(
+                    'Chord line is None. You must compute it first')
+            plt.plot(self.chord_line[0], self.chord_line[1])
+
+        if camber_line:
+            if self.camber_line is None:
+                raise ValueError(
+                    'Camber line is None. You must compute it first')
+            plt.plot(self.camber_line[0], self.camber_line[1])
+
+        if ref_point:
+            plt.scatter(self.reference_point[0], self.reference_point[1])
+
         plt.grid(linestyle='dotted')
         plt.axis('equal')
 
         if outfile:
             if not isinstance(outfile, str):
                 raise ValueError('Output file name must be string.')
             plt.savefig(outfile)
+        else:
+            plt.show()

bladex/profiles.py

@@ -145,7 +145,7 @@ class NacaProfile(ProfileBase):
     - Abbott, Ira (1959). Theory of Wing Sections: Including a Summary of
       Airfoil Data. New York: Dover Publications. p. 115. ISBN 978-0486605869.
 
-    :param string digits: 4 or 5 digits that describes the NACA profile
+    :param str digits: 4 or 5 digits that describes the NACA profile
     :param int n_points: number of discrete points that represents the
         airfoil profile. Default value is 240
     :param bool cosine_spacing: if True, then a cosine spacing is used for the
@@ -205,8 +205,7 @@ def _generate_coordinates(self):
 
             if p == 0:
                 # Symmetric foil
-                self.xup_coordinates = np.linspace(
-                    0.0, 1.0, num=self.n_points)
+                self.xup_coordinates = np.linspace(0.0, 1.0, num=self.n_points)
                 self.yup_coordinates = yt
                 self.xdown_coordinates = np.linspace(
                     0.0, 1.0, num=self.n_points)
@@ -267,8 +266,7 @@ def _generate_coordinates(self):
 
             if p == 0:
                 # Symmetric foil
-                self.xup_coordinates = np.linspace(
-                    0.0, 1.0, num=self.n_points)
+                self.xup_coordinates = np.linspace(0.0, 1.0, num=self.n_points)
                 self.yup_coordinates = yt
                 self.xdown_coordinates = np.linspace(
                     0.0, 1.0, num=self.n_points)