Merge pull request #24 from mahgadalla/dev

Tutorials and Readme

Author: mtezzele

README.md

@@ -1,34 +1,43 @@
-**BladeX**: Python Package for Blade Generation
+**BladeX**: Python Package for Blade Deformation
 
 <p align="center">
-    <a href="https://github.com/mathLab/BladeX/blob/master/LICENSE" target="_blank">
+  <a href="http://mathlab.github.io/BladeX/" target="_blank" >
+    <img alt="Python Package for Blade Deformation" src="docs/source/_static/logo_bladex.png" width="200" />
+  </a>
+</p>
+<p align="center">
+    <a href="LICENSE.rst" target="_blank">
         <img alt="Software License" src="https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square">
     </a>
     <a href="https://travis-ci.org/mathLab/BladeX" target="_blank">
         <img alt="Build Status" src="https://travis-ci.org/mathLab/BladeX.svg">
     </a>
-    <a href="https://coveralls.io/github/mathLab/BladeX" target="_blank">
-        <img alt="Coverage Status" src="https://coveralls.io/repos/github/mathLab/BladeX/badge.svg">
+    <a href="https://coveralls.io/github/mathLab/BladeX?branch=master" target="_blank">
+        <img alt="Coverage Status" src="https://coveralls.io/repos/github/mathLab/BladeX/badge.svg?branch=master">
     </a>
     <a href="https://www.codacy.com/app/mathLab/BladeX?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=mathLab/BladeX&amp;utm_campaign=Badge_Grade" target="_blank">
         <img alt="Codacy Badge" src="https://api.codacy.com/project/badge/Grade/75f02cdeed684c25a273eaffb0d89880">
     </a>
 </p>
 
+[BladeX](http://mathlab.github.io/BladeX/) (Python Blade Deformation) is a Python package for geometrical parametrization and bottom-up construction of propeller blades. It allows to generate and deform a blade based on the radial distribution of its parameters.
+
 ## Table of contents
 * [Description](#description)
 * [Dependencies and installation](#dependencies-and-installation)
 	* [Installing from source](#installing-from-source)
 * [Documentation](#documentation)
 * [Testing](#testing)
+* [Examples](#examples)
 * [Authors and contributors](#authors-and-contributors)
 * [How to contribute](#how-to-contribute)
 	* [Submitting a patch](#submitting-a-patch) 
 * [License](#license)
 
 ## Description
-**BladeX** is a Python package for blade generation.
+**BladeX** is a Python package for geometrical parametrization and bottom-up construction of propeller blades. It allows to generate and deform a blade based on the radial distribution of its parameters such as `pitch`, `rake`, `skew`, and the sectional foils' parameters such as `chord` and `camber`. The package is ideally suited for parametric simulations on large number of blade deformations. It provides an automated procedure for the CAD generation, hence reducing the time and effort required for modelling. The main scope of BladeX is to deal with propeller blades, however it can be flexible to be applied on further applications with analogous geometrical structures such as aircraft wings, turbomachinery, or wind turbine blades.
 
+See the [**Examples**](#examples) section below and the [**Tutorials**](tutorials/README.md) to have an idea of the potential of this package.
 
 ## Dependencies and installation
 **BladeX** requires requires `numpy`, `scipy`, `matplotlib`, and `sphinx` (for the documentation). The code is compatible with Python 2.7 and Python 3.6. It can be installed using `pip` or directly from the source code.
@@ -73,13 +82,24 @@ To run tests locally:
 > python test.py
 ```
 
+## Examples
+You can find useful tutorials on how to use the package in the [tutorials](tutorials/README.md) folder.
+Here we show a bottom-up parametrized construction of the [Potsdam Propeller Test Case (PPTC)](https://www.sva-potsdam.de/pptc-smp11-workshop) provided the sectional profiles as well as the radial distribution of the `pitch`, `rake`, `skew`. The blade is generated and exported to .iges and .stl formats.
+
+<p align="center">
+<img src="readme/PPTC.png" alt>
+</p>
+<p align="center">
+<em>PPTC blade generation according to the radial distribution of the pitch, rake, skew. The generated blade is then exported to .iges and .stl formats.</em>
+</p>
+
 
 ## Authors and contributors
 **BladeX** is currently developed and mantained at [SISSA mathLab](http://mathlab.sissa.it/) by
+* [Mahmoud Gadalla](mailto:[email protected])
 * [Marco Tezzele](mailto:[email protected])
-* [Mahmoud Gadalla](mailto:[email protected])
 
-under the supervision of [Prof. Gianluigi Rozza](mailto:[email protected]).
+under the supervision of [Dr. Andrea Mola](mailto:[email protected]) and [Prof. Gianluigi Rozza](mailto:[email protected]).
 
 Contact us by email for further information or questions about **BladeX**, or suggest pull requests. Contributions improving either the code or the documentation are welcome!
 

bladex/blade.py

@@ -235,8 +235,8 @@ def _planar_to_cylindrical(self):
             y_section_up = radius * np.sin(theta_up)
             y_section_down = radius * np.sin(theta_down)
 
-            z_section_up = -radius * np.cos(theta_up)
-            z_section_down = -radius * np.cos(theta_down)
+            z_section_up = radius * np.cos(theta_up)
+            z_section_down = radius * np.cos(theta_down)
 
             self.blade_coordinates_up.append(
                 np.array([section.xup_coordinates, y_section_up, z_section_up]))

bladex/deform.py

@@ -145,9 +145,9 @@ def _optimum_control_points(X, Y, degree, nbasis, rbf_points):
         # x and y of the ctrl points with constrained least square.
         # we subtract the contribution of the first and last basis function
         cvt_x = np.linalg.lstsq(
-            At, X - A[:, 0] * X[0] - A[:, -1] * X[-1])[0]
+            At, X - A[:, 0] * X[0] - A[:, -1] * X[-1], rcond=-1)[0]
         cvt_y = np.linalg.lstsq(
-            At, Y - A[:, 0] * Y[0] - A[:, -1] * Y[-1])[0]
+            At, Y - A[:, 0] * Y[0] - A[:, -1] * Y[-1], rcond=-1)[0]
 
         # fill with the constraints the first and last point
         opt_ctrl = np.zeros((nbasis, 2))
@@ -251,8 +251,7 @@ def update_control_points(self, param):
         if not self.control_points[param].shape[0] == len(
                 self.param.deformations[param]):
             raise ValueError(
-                'array of deformations must equal to number of control points'
-            )
+                'array of deformations must equal to number of control points')
 
         for i in range(self.control_points[param].shape[0]):
             self.control_points[param][i, 1] += self.param.deformations[param][
@@ -364,40 +363,41 @@ def compute_all(self,
             self.generate_spline(param=param)
             self.compute_deformed_parameters(param=param, tol=tols[param])
 
-    def plot(self,
-             param,
-             original=True,
-             ctrl_points=True,
-             spline=True,
-             rbf=False,
-             rbf_points=500,
-             deformed=False,
-             outfile=None):
+    def _plot_parametric_curve(self,
+                               param,
+                               original=True,
+                               ctrl_points=True,
+                               spline=True,
+                               rbf=False,
+                               rbf_points=500,
+                               deformed=False,
+                               outfile=None):
         """
-        Plot the parametric curve. Several options can be specified.
+        Private method to plot the parametric curve. Several options
+        can be specified.
 
         :param str param: parameter corresponding to the parametric curve
             needs to be plotted. possible values are `chord`, `pitch`, `rake`,
             `skew`, `camber`
         :param bool original: if True, then plot the original points of the
-            parameter at the radii sections. Default value is True
+            parameter at the radii sections.
         :param bool ctrl_points: if True, then plot the control points of
-            that parametric curve. Default value is True
+            that parametric curve.
         :param bool spline: If True, then plot the B-spline interpolation of
-            the parametric curve. Default value is True
+            the parametric curve.
         :param bool rbf: if True, then plot the radial basis functions
-            interpolation of the parametric curve. Default value is True
+            interpolation of the parametric curve.
         :param int rbf_points: number of points used for the rbf interpolation,
             if the flag `rbf` is set True. Beware that this argument does not
             have the same function of that when computing the control points,
             although both uses the radial basis function interpolation with
-            the Wendland basis. Default value is 500
+            the Wendland basis.
         :param bool deformed: if True, then plot the deformed points of the
             parameter radial distribution, estimated using the B-spline
-            interpolations within a given tolerance. Default value is False
+            interpolations within a given tolerance.
         :param str outfile: if string is passed, then the plot is saved
             with that name. If the value is None, then the plot is shown on
-            the screen. Default value is None
+            the screen.
         """
         self._check_param(param=param)
 
@@ -457,6 +457,56 @@ def plot(self,
         else:
             plt.show()
 
+    def plot(self,
+             param,
+             original=True,
+             ctrl_points=True,
+             spline=True,
+             rbf=False,
+             rbf_points=500,
+             deformed=False,
+             outfile=None):
+        """
+        Plot the parametric curve. Several options
+        can be specified.
+
+        :param array_like param: array_like of strings corresponding to the
+            parametric curve that needs to be plotted. possible values are
+            `chord`, `pitch`, `rake`, `skew`, `camber`
+        :param bool original: if True, then plot the original points of the
+            parameter at the radii sections. Default value is True
+        :param bool ctrl_points: if True, then plot the control points of
+            that parametric curve. Default value is True
+        :param bool spline: If True, then plot the B-spline interpolation of
+            the parametric curve. Default value is True
+        :param bool rbf: if True, then plot the radial basis functions
+            interpolation of the parametric curve. Default value is True
+        :param int rbf_points: number of points used for the rbf interpolation,
+            if the flag `rbf` is set True. Beware that this argument does not
+            have the same function of that when computing the control points,
+            although both uses the radial basis function interpolation with
+            the Wendland basis. Default value is 500
+        :param bool deformed: if True, then plot the deformed points of the
+            parameter radial distribution, estimated using the B-spline
+            interpolations within a given tolerance. Default value is False
+        :param str outfile: if string is passed, then the plot is saved
+            with that name. If the value is None, then the plot is shown on
+            the screen. Default value is None
+        """
+        if not isinstance(param, (list, tuple, np.ndarray)):
+            param = [param]
+
+        for par in param:
+            self._plot_parametric_curve(
+                param=par,
+                original=original,
+                ctrl_points=ctrl_points,
+                spline=spline,
+                rbf=rbf,
+                rbf_points=rbf_points,
+                deformed=deformed,
+                outfile=outfile)
+
     def export_param_file(self, outfile='parameters_mod.prm'):
         """
         Export a new parameter file with the new deformed parameters, while
@@ -471,7 +521,10 @@ def export_param_file(self, outfile='parameters_mod.prm'):
         prm.radii = self.param.radii
         params = ['chord', 'pitch', 'rake', 'skew', 'camber']
         for param in params:
-            prm.parameters[param] = self.deformed_parameters[param]
+            if np.all(self.param.deformations[param] == 0):
+                prm.parameters[param] = self.param.parameters[param]
+            else:
+                prm.parameters[param] = self.deformed_parameters[param]
             prm.nbasis[param] = self.param.nbasis[param]
             prm.degree[param] = self.param.nbasis[param]
             prm.npoints[param] = self.param.npoints[param]

bladex/profilebase.py

@@ -439,10 +439,10 @@ def rotate(self, rad_angle=None, deg_angle=None):
             raise ValueError(
                 'You have to pass either the angle in radians or in degrees,' \
                 ' not both.')
-        if rad_angle:
+        if rad_angle is not None:
             cosine = np.cos(rad_angle)
             sine = np.sin(rad_angle)
-        elif deg_angle:
+        elif deg_angle is not None:
             cosine = np.cos(np.radians(deg_angle))
             sine = np.sin(np.radians(deg_angle))
         else:
@@ -540,8 +540,14 @@ def plot(self,
             raise ValueError('One or all the coordinates have None value.')
 
         if profile:
-            plt.plot(self.xup_coordinates, self.yup_coordinates, label='Upper profile')
-            plt.plot(self.xdown_coordinates, self.ydown_coordinates, label='Lower profile')
+            plt.plot(
+                self.xup_coordinates,
+                self.yup_coordinates,
+                label='Upper profile')
+            plt.plot(
+                self.xdown_coordinates,
+                self.ydown_coordinates,
+                label='Lower profile')
 
         if chord_line:
             if self.chord_line is None:
@@ -553,10 +559,15 @@ def plot(self,
             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], label='Camber line')
+            plt.plot(
+                self.camber_line[0], self.camber_line[1], label='Camber line')
 
         if ref_point:
-            plt.scatter(self.reference_point[0], self.reference_point[1], s=15, label='Reference point')
+            plt.scatter(
+                self.reference_point[0],
+                self.reference_point[1],
+                s=15,
+                label='Reference point')
 
         plt.grid(linestyle='dotted')
         plt.axis('equal')

docs/source/_static/logo_bladex.png

@@ -267,31 +267,32 @@ def test_transformations_reflect_blade_up(self):
         blade = create_sample_blade_NACA()
         blade.apply_transformations(reflect=True)
         blade_coordinates_up_expected = np.load(
-            'tests/test_datasets/blade_up_after_transformation_flip.npy')
+            'tests/test_datasets/blade_up_after_transformation_reflect.npy')
         np.testing.assert_almost_equal(blade.blade_coordinates_up,
                                        blade_coordinates_up_expected)
 
     def test_transformations_reflect_blade_down(self):
         blade = create_sample_blade_NACA()
         blade.apply_transformations(reflect=True)
         blade_coordinates_down_expected = np.load(
-            'tests/test_datasets/blade_down_after_transformation_flip.npy')
+            'tests/test_datasets/blade_down_after_transformation_reflect.npy')
         np.testing.assert_almost_equal(blade.blade_coordinates_down,
                                        blade_coordinates_down_expected)
 
     def test_transformations_no_reflect_blade_up(self):
         blade = create_sample_blade_NACA()
         blade.apply_transformations(reflect=False)
         blade_coordinates_up_expected = np.load(
-            'tests/test_datasets/blade_up_after_transformation_no_flip.npy')
+            'tests/test_datasets/blade_up_after_transformation_no_reflect.npy')
         np.testing.assert_almost_equal(blade.blade_coordinates_up,
                                        blade_coordinates_up_expected)
 
     def test_transformations_no_reflect_blade_down(self):
         blade = create_sample_blade_NACA()
         blade.apply_transformations(reflect=False)
         blade_coordinates_down_expected = np.load(
-            'tests/test_datasets/blade_down_after_transformation_no_flip.npy')
+            'tests/test_datasets/blade_down_after_transformation_no_reflect.npy'
+        )
         np.testing.assert_almost_equal(blade.blade_coordinates_down,
                                        blade_coordinates_down_expected)