From 37ed1e2b0573033626981bfd5278c7a6263d688e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Enrique=20Mill=C3=A1n=20Valbuena?= Date: Fri, 25 Sep 2020 16:31:23 +0200 Subject: [PATCH] Feature/compute performance (#32) * ENH: Implement correct parametrization of the dimensionless radii bounds * CLN, TST: Remove old tests from previous version * ENH, TST: Include force and torque coefficient calculation * TST: Update test outcome values based on realistic J values * DOC, CLN: Clean up and update documentation --- .vscode/settings.json | 3 - README.md | 117 +-- Solving with mock airfoil.py | 290 -------- data/.vscode/settings.json | 3 - examples/base_airfoil.py | 41 ++ sandbox/fixing-new-implementation.ipynb | 392 ---------- sandbox/new_implementation.py | 135 ---- sandbox/robust-implementation-J-loop.ipynb | 664 ----------------- sandbox/robust-implementation.ipynb | 805 --------------------- src/pybem/bem/model.py | 359 +++++---- tests/_test_no_tip_loss.py | 52 -- tests/_test_tip_loss.py | 52 -- tests/bem/test_model.py | 132 ++-- 13 files changed, 386 insertions(+), 2659 deletions(-) delete mode 100644 .vscode/settings.json delete mode 100644 Solving with mock airfoil.py delete mode 100644 data/.vscode/settings.json create mode 100644 examples/base_airfoil.py delete mode 100644 sandbox/fixing-new-implementation.ipynb delete mode 100644 sandbox/new_implementation.py delete mode 100644 sandbox/robust-implementation-J-loop.ipynb delete mode 100644 sandbox/robust-implementation.ipynb delete mode 100644 tests/_test_no_tip_loss.py delete mode 100644 tests/_test_tip_loss.py diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 2b274b5..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "python.pythonPath": "D:\\Users\\emillan\\envs\\pybem\\python.exe" -} \ No newline at end of file diff --git a/README.md b/README.md index 3067d8f..74cdc46 100644 --- a/README.md +++ b/README.md @@ -1,69 +1,74 @@ # pybem - [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0) [![Build Status](https://travis-ci.org/KikeM/pybem.svg?branch=master)](https://travis-ci.org/KikeM/pybem) Blade Element Method implementation for propeller calculations. -## Iteration process - -![Robust Iteration steps](robust_iteration.png) - -## Quickstart - -```python -import matplotlib.pyplot as plt - -import numpy as np -from pybem import BladeElementMethod - -bem = BladeElementMethod() - -# Quick polar -# ----------------------------- -def cl(alpha): - - from math import pi - - return 2*pi*(alpha) +## Installation -def cd(cl): - - return 0.012 + 0.05 * cl**2 - -alpha = np.linspace(-40, 40, 50) -alpha_r = np.deg2rad(alpha) - -cl_alpha = cl(alpha_r) -cd_polar = cd(cl_alpha) - -# ------------------------------- +To run it as a user, simply invoke `pip`: +```bash +pip install . +``` -# Lenghts -D = 0.152 * 2 # meters -r_tip = D / 2.0 -r_hub = r_tip * 0.15 +### For developers -# Propeller -# --------------------------------- -r = np.linspace(r_hub, r_tip) -beta = np.linspace(80, 50) -chord = 0.2 * r -# --------------------------------- +If you want to contribute to the library, or tweak it to your own needs, install it in developer mode, including the development libraries: +```bash +pip install -e . --requirement requirements-dev.txt +``` -# Load airfoil -bem.load_airfoil(alpha, cl_alpha, cd_polar) +## Quickstart -# Load advance ratio -J = 1 -bem.load_similarity(J = J) +Running the code consists of easy and uncoupled steps: +1. Declare the airfoil sections with their corresponding geometrical definition. +1. Create a propeller by putting together the sections and the number of blades. +1. Create a solver by putting together the propeller and a advance ratio. +1. Solve the flow. +1. Compute the force and torque coefficients. -prop = bem.load_propeller(dist_r=r, dist_beta=beta, dist_chord = chord, n_blades = 4) -bem.set_tip_loss(True) +Here is an example with an airfoil defined by an analytical lift and drag polars. -# Test! -_r = r[25] / D -phi0 = np.arctan(J/_r) -phi0 = np.rad2deg(phi0) -phi = bem.compute_inflow_angle(_r, phi0) -``` +```python +from pybem.models import Propeller, Section, BaseAirfoil +from pybem.bem import BladeElementMethod + +# Define known sections +sections = [ + Section( + name="Hub", + r=0.3, + beta=60, + chord=0.4, + airfoil=BaseAirfoil(cl_coeff=1.0, cd_coeff=1e-2), + ), + Section( + name="Middle", + r=0.6, + beta=45, + chord=0.35, + airfoil=BaseAirfoil(cl_coeff=0.85, cd_coeff=1e-3), + ), + Section( + name="Tip", + r=1.2, + beta=30, + chord=0.2, + airfoil=BaseAirfoil(cl_coeff=0.5, cd_coeff=1e-3), + ), +] + +# Define propeller +B = 6 +propeller = Propeller(B=B, sections=sections) + +# Define flow conditions and BEM method +J = 0.2 +bem = BladeElementMethod(J=J, propeller=propeller, tip_loss=False, hub_loss=False) + +# Solve +bem.solve() + +# Compute forces +CT, CQ = bem.integrate_forces() +``` \ No newline at end of file diff --git a/Solving with mock airfoil.py b/Solving with mock airfoil.py deleted file mode 100644 index 8c40009..0000000 --- a/Solving with mock airfoil.py +++ /dev/null @@ -1,290 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - -# http://hartzellprop.com/wp-content/uploads/Hartzell-Propeller-Others-Full-Catalog.pdf -# -# https://www.airforce-technology.com/projects/aermacchisf260traine/ -# -# https://m-selig.ae.illinois.edu/props/propDB.html -# -# https://www.airliners.net/aircraft-data/aermacchi-f-260/3 -# - -# In[1]: - - -import numpy as np -import pandas as pd - -import matplotlib.pyplot as plt - -from math import pi - - -# In[2]: - - -def cl(alpha): - - from math import pi - - return 2 * pi * (alpha) - - -def cd(cl): - - return 0.012 + 0.05 * cl ** 2 - - -# In[101]: - - -# Test polar -cl(np.deg2rad(10)) -cd(1.0) - -# Prandtl tip loss -F = 1 - -solidity = 0.2 - -# Foil angle -beta = 20 - -# Airspeed -V_inf = 300 # km/h -V_inf = V_inf * 1000 / 3600 -V_inf - -rho = 1.0 - -# Rotation -omega = 2700 # rpm -omega = omega * (2 * pi) / 60 -omega - -# Lenghts -D = 2.032 # meters - -r_tip = D / 2 -r_hub = r_tip * 0.2 - -(r_tip, r_hub) - - -# In[4]: - - -from scipy.optimize import newton_krylov - - -# In[5]: - - -def axial_induction(phi): - - # Convert to radians - _beta, _phi = np.deg2rad([beta, phi]) - - # Compute angle of attack - _alpha = _beta - _phi - - # Polar - _cl = cl(_alpha) - _cd = cd(_cl) - - num = 4.0 * F * (np.sin(_phi)) ** 2.0 - den = solidity * (_cl * np.cos(_phi) - _cd * np.sin(_phi)) - - frac = num / den - 1 - - return 1.0 / frac - - -# In[93]: - - -def tangential_induction(phi): - - # Convert to radians - _beta, _phi = np.deg2rad([beta, phi]) - - # Compute angle of attack - _alpha = _beta - _phi - - # Polar - _cl = cl(_alpha) - _cd = cd(_cl) - - num = 4.0 * F * np.sin(_phi) * np.cos(_phi) - den = solidity * (_cl * np.sin(_phi) - _cd * np.cos(_phi)) - - frac = num / den + 1 - - return 1.0 / frac - - -# In[7]: - - -axial_induction(2) -tangentail_induction(2) - - -# In[94]: - - -def residual(phi, r): - - _phi = np.deg2rad(phi) - - _v = V_inf / omega / r - - ax = axial_induction(phi) - tng = tangential_induction(phi) - - return np.tan(_phi) - _v * ((1 + ax) / (1 - tng)) - - -# In[14]: - - -from functools import partial - - -# In[148]: - - -solutions = [] - -beta = 40 -sol = 50 - -for radius in np.linspace(r_hub, r_tip): - - _residual = partial(residual, r=radius) - try: - sol = newton_krylov(_residual, sol) - except Exception as ex: - solutions.append([radius, np.nan, beta]) - - solutions.append([radius, sol.tolist(), beta]) - - -# In[149]: - - -results_df = pd.DataFrame(solutions, columns=["r", "phi", "beta"]).set_index("r") - - -# In[150]: - - -ax = results_df.pivot(columns="beta", values="phi").plot() - -ax.set_title("Incidence angle") -ax.set_ylabel("$\\phi$") -ax.set_xlabel("$r$") -ax.grid(True) - - -# # Integration - -# In[151]: - - -def compute_inductions(x0, radius): - - # Create residual function with current position - _residual = partial(residual, r=radius) - - # Attempt solution - try: - sol = newton_krylov(_residual, x0) - except Exception as ex: - sol = np.nan - - return sol - - -# In[152]: - - -(r_tip - r_hub) / 0.05 - - -# In[153]: - - -dr = 0.01 -N = np.floor((r_tip - r_hub) / dr) - -T_hat = [0.0] -Q_hat = [0.0] - -phi = 50 - -beta = 40 - -q_inf = 4 * pi * rho * V_inf ** 2.0 - -r_space = np.linspace(r_hub, r_tip, N) - -idx = 0 -for r in r_space[1:]: - - # Compute induction angle - phi = compute_inductions(phi, r) - - # Compute induction coefficients - axi = axial_induction(phi) - tng = tangential_induction(phi) - - # Compute forcing terms - F_T = (r + dr) ** 1.0 * (1 + axi) * axi * F - F_Q = (r + dr) ** 3.0 * (1 + axi) * tng * F - - T_hat.append(T_hat[idx] + dr * F_T) - Q_hat.append(Q_hat[idx] + dr * F_Q) - - idx += 1 - -T_hat = np.array(T_hat) -Q_hat = np.array(Q_hat) - -# Give proper dimensions -T = np.array(T_hat) -Q = np.array(Q_hat) - -T *= q_inf -Q *= q_inf * omega - - -# In[154]: - - -fig, axes = plt.subplots(figsize=(8, 5)) - -axes.plot(r_space, T_hat, label="$\hat{T}$") -axes.plot(r_space, Q_hat, label="$\hat{Q}$") - -axes.set_title("Dimensionless thrust vs. torque") -axes.legend() -axes.grid(True) - - -# In[155]: - - -fig, axes = plt.subplots(ncols=2, figsize=(15, 5)) - -axes[0].plot(r_space, T) -axes[1].plot(r_space, Q) - -axes[0].set_title("Thrust") -axes[1].set_title("Torque") - -for ax in axes: - ax.set_xlabel("$r$") -for ax in axes: - ax.grid(True) diff --git a/data/.vscode/settings.json b/data/.vscode/settings.json deleted file mode 100644 index 9bc393c..0000000 --- a/data/.vscode/settings.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "python.pythonPath": "D:\\Users\\emillan\\envs\\tomas\\python.exe" -} \ No newline at end of file diff --git a/examples/base_airfoil.py b/examples/base_airfoil.py new file mode 100644 index 0000000..ced9958 --- /dev/null +++ b/examples/base_airfoil.py @@ -0,0 +1,41 @@ +from pybem.models import Propeller, Section, BaseAirfoil +from pybem.bem import BladeElementMethod + +# Define known sections +sections = [ + Section( + name="Hub", + r=0.3, + beta=60, + chord=0.4, + airfoil=BaseAirfoil(cl_coeff=1.0, cd_coeff=1e-2), + ), + Section( + name="Middle", + r=0.6, + beta=45, + chord=0.35, + airfoil=BaseAirfoil(cl_coeff=0.85, cd_coeff=1e-3), + ), + Section( + name="Tip", + r=1.2, + beta=30, + chord=0.2, + airfoil=BaseAirfoil(cl_coeff=0.5, cd_coeff=1e-3), + ), +] + +# Define propeller +B = 6 +propeller = Propeller(B=B, sections=sections) + +# Define flow conditions and BEM method +J = 0.2 +bem = BladeElementMethod(J=J, propeller=propeller, tip_loss=False, hub_loss=False) + +# Solve +bem.solve() + +# Compute forces +CT, CQ = bem.integrate_forces() diff --git a/sandbox/fixing-new-implementation.ipynb b/sandbox/fixing-new-implementation.ipynb deleted file mode 100644 index 7c8d5de..0000000 --- a/sandbox/fixing-new-implementation.ipynb +++ /dev/null @@ -1,392 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import pickle\n", - "from functools import partial\n", - "from math import pi\n", - "from pathlib import Path\n", - "\n", - "import matplotlib.pyplot as plt\n", - "plt.style.use('ggplot')\n", - "import numpy as np\n", - "import pandas as pd\n", - "from scipy.optimize import newton_krylov\n", - "\n", - "from tqdm import tqdm_notebook as tqdm\n", - "\n", - "from pybem.core import Airfoil, Propeller" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "################################################################################\n", - "path_polar = Path(r'D:\\Users\\emillan\\misCodigos\\Notebooks\\pybem\\pybem\\data\\naca2415_extended.csv')\n", - "\n", - "airfoil_data_df = pd.read_csv(path_polar.open(mode='r')) \n", - "airfoil_data_df = airfoil_data_df.astype(float)\n", - "\n", - "alpha = airfoil_data_df['Alpha'].values\n", - "polar_cl = airfoil_data_df['Cl'].values\n", - "polar_cd = airfoil_data_df['Cd'].values\n", - "\n", - "airfoil = Airfoil(alpha, polar_cl, polar_cd)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "phi_0 45.0\n", - "phi_N 26.56505117707799\n" - ] - } - ], - "source": [ - "################################################################################\n", - "\n", - "# Create propeller parameters\n", - "J = 0.25\n", - "D = 1.0\n", - "N_b = 8\n", - "\n", - "def solidity(r):\n", - " NUM = 2.0 * pi * r * D \n", - " DEN = N_b * propeller.chord(r)\n", - " return NUM / DEN\n", - "\n", - "def tan_phi(r):\n", - " return J / r\n", - "\n", - "# Create distributions\n", - "N = 50\n", - "# r_hat = r / D\n", - "r_hat = np.linspace(0.25, 0.5, N)\n", - "chord = np.linspace(1.0, 0.5, N)\n", - "\n", - "tan0 = np.rad2deg(np.arctan(tan_phi(r_hat[0])))\n", - "tanN = np.rad2deg(np.arctan(tan_phi(r_hat[-1])))\n", - "\n", - "print('phi_0', tan0)\n", - "print('phi_N', tanN)\n", - "\n", - "twist = np.linspace(tan0, tanN, N) * 1.4\n", - "\n", - "propeller = Propeller(r_hub = 0.0, \n", - " r_tip = 0.0,\n", - " r_dist = r_hat,\n", - " beta_dist = twist,\n", - " chord_dist = chord)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "################################################################################\n", - "def residual(theta, r):\n", - "\n", - " _S = solidity(r)\n", - " \n", - " # Compute base effective pitch\n", - " _tan_phi = tan_phi(r) \n", - " phi0 = np.rad2deg(np.arctan(_tan_phi))\n", - "\n", - " # Compute airfoil angle\n", - " _twist = propeller.beta(r)\n", - " _alpha = _twist - (phi0 + theta)\n", - " \n", - " # return phi0, _alpha, _twist\n", - "\n", - " try:\n", - " _cl = airfoil.cl(_alpha)\n", - " _cd = airfoil.cd(_cl)\n", - " except:\n", - " print('phi0:', phi0)\n", - " print('twist:', _twist)\n", - " print('alpha:', _alpha)\n", - " print('theta:', theta)\n", - " raise ValueError\n", - "\n", - " _tan_gamma = _cd / _cl\n", - "\n", - " # Get angles in the right degrees\n", - " _theta = np.deg2rad(theta)\n", - " _phi = np.deg2rad(phi0 + theta)\n", - "\n", - " NUM = 1.0 - _tan_gamma * np.tan(_theta)\n", - " DEN = 4.0 * np.sin(_phi) * np.tan(_theta)\n", - "\n", - " return _S / _cl - NUM / DEN " - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "916dfef72a5e4314aefb4894207c11d6", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "inference_angles = []\n", - "\n", - "for radius in tqdm(r_hat):\n", - " _residual = partial(residual, r = radius)\n", - " inference_angles.append({'r': radius, 'theta': newton_krylov(_residual, 0.5, iter = 1000).item()})\n", - "\n", - "theta_df = pd.DataFrame(inference_angles).set_index('r') " - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "theta_df = pd.DataFrame(inference_angles).set_index('r')" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "theta_df.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.25 , 0.25510204, 0.26020408, 0.26530612, 0.27040816,\n", - " 0.2755102 , 0.28061224, 0.28571429, 0.29081633, 0.29591837,\n", - " 0.30102041, 0.30612245, 0.31122449, 0.31632653, 0.32142857,\n", - " 0.32653061, 0.33163265, 0.33673469, 0.34183673, 0.34693878,\n", - " 0.35204082, 0.35714286, 0.3622449 , 0.36734694, 0.37244898,\n", - " 0.37755102, 0.38265306, 0.3877551 , 0.39285714, 0.39795918,\n", - " 0.40306122, 0.40816327, 0.41326531, 0.41836735, 0.42346939,\n", - " 0.42857143, 0.43367347, 0.43877551, 0.44387755, 0.44897959,\n", - " 0.45408163, 0.45918367, 0.46428571, 0.46938776, 0.4744898 ,\n", - " 0.47959184, 0.48469388, 0.48979592, 0.49489796, 0.5 ])" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "r_hat" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [], - "source": [ - "def angles_distribution(theta, r):\n", - "\n", - " _S = solidity(r)\n", - " \n", - " # Compute base effective pitch\n", - " _tan_phi = tan_phi(r) \n", - " phi0 = np.rad2deg(np.arctan(_tan_phi))\n", - "\n", - " # Compute airfoil angle\n", - " _twist = propeller.beta(r)\n", - " _alpha = _twist - (phi0 + theta)\n", - "\n", - " _cl = airfoil.cl(_alpha)\n", - " _cd = airfoil.cd(_cl)\n", - "\n", - " _tan_gamma = _cd / _cl\n", - "\n", - " # Get angles in the right degrees\n", - " _theta = np.deg2rad(theta)\n", - " _phi = phi0 + theta\n", - "\n", - " return {'twist': _twist, 'alpha':_alpha, 'phi0': phi0, 'phi': _phi, 'r': r, 'theta': theta, 'S_cl': _S / _cl}\n", - "\n", - "#%%\n", - "distributions = []\n", - "\n", - "for radius in theta_df.index:\n", - " distributions.append(angles_distribution(theta_df.loc[radius].values[0], radius))\n", - "\n", - "distributions_df = pd.DataFrame(distributions)\n", - "distributions_df = distributions_df.set_index('r')\n", - "#%%" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ],\n", - " dtype=object)" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "distributions_df.plot(subplots=True, figsize = (10,15))" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "distributions_df.reset_index().set_index('theta')['S_cl'].plot()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "pybem", - "language": "python", - "name": "pybem" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/sandbox/new_implementation.py b/sandbox/new_implementation.py deleted file mode 100644 index 923ca5b..0000000 --- a/sandbox/new_implementation.py +++ /dev/null @@ -1,135 +0,0 @@ -import pickle -from functools import partial -from math import pi -from pathlib import Path - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -from scipy.optimize import newton_krylov - -from pybem.core import Airfoil, Propeller - -################################################################################ -path_polar = Path("./data/naca2415.csv") - -airfoil_data_df = pd.read_csv(path_polar.open(mode="r")) -airfoil_data_df = airfoil_data_df.astype(float) - -alpha = airfoil_data_df["Alpha"].values -polar_cl = airfoil_data_df["Cl"].values -polar_cd = airfoil_data_df["Cd"].values - -airfoil = Airfoil(alpha, polar_cl, polar_cd) -################################################################################ - -# Create propeller parameters -J = 0.15 -D = 1.0 -N_b = 4 - - -def solidity(r): - NUM = 2.0 * pi * r * D - DEN = N_b * propeller.chord(r) - return NUM / DEN - - -def tan_phi(r): - return J / r / 2.0 / pi - - -# Create distributions -N = 50 -# r_hat = r / D -r_hat = np.linspace(0.1, 0.5, N) -chord = np.linspace(1.0, 0.25, N) - -tan0 = np.rad2deg(np.arctan(tan_phi(r_hat[0]))) -tanN = np.rad2deg(np.arctan(tan_phi(r_hat[-1]))) -twist = np.linspace(tan0, tanN, N) * 1.35 - -propeller = Propeller( - r_hub=0.0, r_tip=0.0, r_dist=r_hat, beta_dist=twist, chord_dist=chord -) - - -################################################################################ -def residual(theta, r): - - _S = solidity(r) - - # Compute base effective pitch - _tan_phi = tan_phi(r) - phi0 = np.rad2deg(np.arctan(_tan_phi)) - - # Compute airfoil angle - _twist = propeller.beta(r) - _alpha = _twist - (phi0 - theta) - - try: - _cl = airfoil.cl(_alpha) - _cd = airfoil.cd(_cl) - except: - print("phi0:", phi0) - print("twist:", _twist) - print("alpha:", _alpha) - print("theta:", theta) - raise ValueError - - _tan_gamma = _cd / _cl - - # Get angles in the right degrees - _theta = np.deg2rad(theta) - _phi = np.deg2rad(phi0 + theta) - - NUM = 1.0 - _tan_gamma * np.tan(_theta) - DEN = 4.0 * np.sin(_phi) * np.tan(_theta) - - return _S / _cl - NUM / DEN - - -inference_angles = [] - -for radius in r_hat: - _residual = partial(residual, r=radius) - inference_angles.append( - {"r": radius, "theta": newton_krylov(_residual, 0.001).item()} - ) - -theta_df = pd.DataFrame(inference_angles).set_index("r") - - -def angles_distribution(theta, r): - - _S = solidity(r) - - # Compute base effective pitch - _tan_phi = tan_phi(r) - phi0 = np.rad2deg(np.arctan(_tan_phi)) - - # Compute airfoil angle - _twist = propeller.beta(r) - _alpha = _twist - (phi0) - - _cl = airfoil.cl(_alpha) - _cd = airfoil.cd(_cl) - - _tan_gamma = _cd / _cl - - # Get angles in the right degrees - _theta = np.deg2rad(theta) - _phi = np.deg2rad(phi0 + theta) - - return {"twist": _twist, "alpha": _alpha, "phi": _phi, "r": r, "theta": theta} - - -#%% -distributions = [] - -for radius in theta_df.index: - distributions.append(angles_distribution(theta_df.loc[radius].values[0], radius)) - -distributions_df = pd.DataFrame(distributions) -distributions_df = distributions_df.set_index("r") -#%% diff --git a/sandbox/robust-implementation-J-loop.ipynb b/sandbox/robust-implementation-J-loop.ipynb deleted file mode 100644 index 5e5b42c..0000000 --- a/sandbox/robust-implementation-J-loop.ipynb +++ /dev/null @@ -1,664 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import pickle\n", - "from functools import partial\n", - "from math import pi\n", - "from pathlib import Path\n", - "\n", - "import matplotlib.pyplot as plt\n", - "plt.style.use('ggplot')\n", - "import numpy as np\n", - "import pandas as pd\n", - "from scipy.optimize import newton_krylov\n", - "\n", - "from tqdm import tqdm_notebook as tqdm\n", - "\n", - "from numpy import tan\n", - "\n", - "from pybem.core import Airfoil, Propeller\n", - "\n", - "from scipy.integrate import simps" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "################################################################################\n", - "path_polar = Path(r'../data/naca2415_extended.csv')\n", - "\n", - "airfoil_data_df = pd.read_csv(path_polar.open(mode='r')) \n", - "airfoil_data_df = airfoil_data_df.astype(float)\n", - "\n", - "alpha = airfoil_data_df['Alpha'].values\n", - "polar_cl = airfoil_data_df['Cl'].values\n", - "polar_cd = airfoil_data_df['Cd'].values\n", - "\n", - "airfoil = Airfoil(alpha, polar_cl, polar_cd)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "def solidity(r):\n", - " NUM = 2.0 * pi * r * D \n", - " DEN = N_b * propeller.chord(r)\n", - " return NUM / DEN\n", - "\n", - "def tan_phi(r):\n", - " return J / r" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "def angles_distribution(theta, r):\n", - "\n", - " _S = solidity(r)\n", - " \n", - " # Compute base effective pitch\n", - " _tan_phi = tan_phi(r) \n", - " phi0 = np.rad2deg(np.arctan(_tan_phi))\n", - "\n", - " # Compute airfoil angle\n", - " _twist = propeller.beta(r)\n", - " _alpha = _twist - (phi0 + theta)\n", - "\n", - " _cl = airfoil.cl(_alpha)\n", - " _cd = airfoil.cd(_cl)\n", - "\n", - " _tan_gamma = _cd / _cl\n", - " _gamma = np.rad2deg(np.arctan(_tan_gamma))\n", - "\n", - " # Get angles in the right degrees\n", - " _phi = phi0 + theta\n", - "\n", - " return {'twist': _twist, \n", - " 'alpha':_alpha, \n", - " 'phi0': phi0, \n", - " 'phi': _phi, \n", - " 'r': r, \n", - " 'theta': theta, \n", - " 'S_cl': _S / _cl, \n", - " 'gamma': _gamma}" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "################################################################################\n", - "def residual(theta, r):\n", - "\n", - " _S = solidity(r)\n", - " \n", - " # Compute base effective pitch\n", - " _tan_phi = tan_phi(r) \n", - " phi0 = np.rad2deg(np.arctan(_tan_phi))\n", - "\n", - " # Compute airfoil angle\n", - " _twist = propeller.beta(r)\n", - " _alpha = _twist - (phi0 + theta)\n", - " \n", - " _cl = airfoil.cl(_alpha)\n", - " _cd = airfoil.cd(_cl)\n", - "\n", - " _tan_gamma = _cd / _cl\n", - "\n", - " # Get angles in the right degrees\n", - " _theta = np.deg2rad(theta)\n", - " _phi = np.deg2rad(phi0 + theta)\n", - "\n", - " NUM = 1.0 - _tan_gamma * np.tan(_theta)\n", - " DEN = 4.0 * np.sin(_phi) * np.tan(_theta)\n", - "\n", - " return _S / _cl - NUM / DEN " - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "def incidence_axial(angles):\n", - " \n", - " phi = np.deg2rad(angles['phi'])\n", - " phi0 = np.deg2rad(angles['phi0'])\n", - " gamma = np.deg2rad(angles['gamma'])\n", - " \n", - " NUM = tan(phi) * (1.0 + tan(phi0) * tan(phi + gamma))\n", - " DEN = tan(phi0) * (1.0 + tan(phi) * tan(phi + gamma))\n", - " \n", - " return NUM / DEN - 1.0\n", - "\n", - "def incidence_radial(angles):\n", - " \n", - " phi = np.deg2rad(angles['phi'])\n", - " phi0 = np.deg2rad(angles['phi0'])\n", - " \n", - " a = incidence_axial(angles)\n", - " \n", - " NUM = tan(phi0) * (1.0 + a)\n", - " DEN = tan(phi)\n", - " \n", - " return 1.0 - NUM / DEN" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def K(angles):\n", - " \n", - " _cl = airfoil.cl(angles['alpha'])\n", - " a = incidence_axial(angles)\n", - " \n", - " phi = np.deg2rad(angles['phi'])\n", - " gamma = np.deg2rad(angles['gamma'])\n", - " \n", - " NUM = _cl * (1.0 + a)**2.0\n", - " DEN = np.sin(phi)**2.0 * np.cos(gamma)\n", - " \n", - " return NUM / DEN\n", - "\n", - "def Tc(angles):\n", - " \n", - " _K = K(angles)\n", - " \n", - " phi = np.deg2rad(angles['phi'])\n", - " gamma = np.deg2rad(angles['gamma'])\n", - " \n", - " return _K * np.cos(phi + gamma)\n", - "\n", - "def Qc(angles):\n", - " \n", - " _K = K(angles)\n", - " \n", - " phi = np.deg2rad(angles['phi'])\n", - " gamma = np.deg2rad(angles['gamma'])\n", - " \n", - " return _K * np.sin(phi + gamma)\n", - "\n", - "def dCT_dr(angles):\n", - " \n", - " _r = angles['r']\n", - " \n", - " _c = propeller.chord(_r)\n", - " \n", - " _Tc = Tc(angles)\n", - " \n", - " return _c * _Tc\n", - "\n", - "def dCQ_dr(angles):\n", - " \n", - " _r = angles['r']\n", - " \n", - " _c = propeller.chord(_r)\n", - " \n", - " _Qc = Qc(angles)\n", - " \n", - " return _r * _c * _Qc" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "09b86db2d428444aaeb5f45365572ca3", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "16061e5401e94598b4b0fd9bd32ff3a7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "69c9930f908b4e908ffc86b17d336c0a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9519b6ae216e42cfba498138ede229e7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e6b2d0f288b948078819e9ccaefc3deb", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "################################################################################\n", - "\n", - "# Create propeller parameters\n", - "J = 0.5\n", - "D = 1.0\n", - "N_b = 8\n", - "\n", - "twist_factor = 1.2\n", - "\n", - "N_J = 10\n", - "N_twist = 5\n", - "\n", - "analysis_df = pd.DataFrame()\n", - "\n", - "counter = 0\n", - "for J in tqdm(np.linspace(0.1, 1.0, N_J)):\n", - " \n", - " for twist_factor in tqdm(np.linspace(1.0, 1.5, N_twist)):\n", - "\n", - " # Create distributions\n", - " N = 50\n", - " # r_hat = r / D\n", - " r_hat = np.linspace(0.25, 0.5, N)\n", - " chord = np.linspace(1.0, 0.5, N)\n", - "\n", - " tan0 = np.rad2deg(np.arctan(tan_phi(r_hat[0])))\n", - " tanN = np.rad2deg(np.arctan(tan_phi(r_hat[-1])))\n", - "\n", - " twist = np.linspace(tan0, tanN, N) * twist_factor\n", - "\n", - " propeller = Propeller(r_hub = 0.0, \n", - " r_tip = 0.0,\n", - " r_dist = r_hat,\n", - " beta_dist = twist,\n", - " chord_dist = chord)\n", - "\n", - " ##############\n", - " inference_angles = []\n", - "\n", - " try:\n", - " for radius in tqdm(r_hat, leave=False):\n", - " _residual = partial(residual, r = radius)\n", - " inference_angles.append({'r': radius, 'theta': newton_krylov(_residual, 0.5, iter = 1000).item()})\n", - "\n", - " theta_df = pd.DataFrame(inference_angles).set_index('r') \n", - " except:\n", - " # Recover data\n", - " analysis_df.loc[counter, 'J'] = J\n", - " analysis_df.loc[counter, 'beta'] = twist_factor\n", - "\n", - " analysis_df.loc[counter, 'CT'] = np.nan\n", - " analysis_df.loc[counter, 'CQ'] = np.nan\n", - " \n", - " continue\n", - "\n", - "\n", - " ###########\n", - " distributions = []\n", - "\n", - " for radius in theta_df.index:\n", - " distributions.append(angles_distribution(theta_df.loc[radius].values[0], radius))\n", - "\n", - " distributions_df = pd.DataFrame(distributions)\n", - " distributions_df = distributions_df.set_index('r')\n", - "\n", - " incidences = []\n", - "\n", - " for angles in distributions:\n", - "\n", - " a = incidence_axial(angles)\n", - " a_prime = incidence_radial(angles)\n", - "\n", - " incidences.append({'a':a, 'a_p': a_prime, 'r': angles['r']})\n", - "\n", - " d_ct = pd.Series()\n", - " d_qt = pd.Series()\n", - "\n", - " for angles in distributions:\n", - " d_ct.loc[angles['r']] = dCT_dr(angles)\n", - " d_qt.loc[angles['r']] = dCQ_dr(angles)\n", - "\n", - " T = pd.Series()\n", - " Q = pd.Series()\n", - "\n", - " for element in d_ct.index:\n", - " T.loc[element] = simps(d_ct.loc[:element].values, d_ct.loc[:element].index.values)\n", - " Q.loc[element] = simps(d_qt.loc[:element].values, d_qt.loc[:element].index.values)\n", - " \n", - " # Recover data\n", - " analysis_df.loc[counter, 'J'] = J\n", - " analysis_df.loc[counter, 'beta'] = twist_factor\n", - " \n", - " analysis_df.loc[counter, 'CT'] = T.tail(1).values[0]\n", - " analysis_df.loc[counter, 'CQ'] = Q.tail(1).values[0]\n", - " \n", - " counter += 1" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
JbetaCTCQ
01.01.5NaNNaN
\n", - "
" - ], - "text/plain": [ - " J beta CT CQ\n", - "0 1.0 1.5 NaN NaN" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "analysis_df" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "pybem", - "language": "python", - "name": "pybem" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.9" - }, - "latex_envs": { - "LaTeX_envs_menu_present": true, - "autoclose": false, - "autocomplete": true, - "bibliofile": "biblio.bib", - "cite_by": "apalike", - "current_citInitial": 1, - "eqLabelWithNumbers": true, - "eqNumInitial": 1, - "hotkeys": { - "equation": "Ctrl-E", - "itemize": "Ctrl-I" - }, - "labels_anchors": false, - "latex_user_defs": false, - "report_style_numbering": false, - "user_envs_cfg": false - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": false, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": false - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/sandbox/robust-implementation.ipynb b/sandbox/robust-implementation.ipynb deleted file mode 100644 index e50d696..0000000 --- a/sandbox/robust-implementation.ipynb +++ /dev/null @@ -1,805 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import pickle\n", - "from functools import partial\n", - "from math import pi\n", - "from pathlib import Path\n", - "\n", - "import matplotlib.pyplot as plt\n", - "plt.style.use('ggplot')\n", - "import numpy as np\n", - "import pandas as pd\n", - "from scipy.optimize import newton_krylov\n", - "\n", - "from tqdm import tqdm_notebook as tqdm\n", - "\n", - "from pybem.core import Airfoil, Propeller" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "################################################################################\n", - "path_polar = Path(r'../data/naca2415_extended.csv')\n", - "\n", - "airfoil_data_df = pd.read_csv(path_polar.open(mode='r')) \n", - "airfoil_data_df = airfoil_data_df.astype(float)\n", - "\n", - "alpha = airfoil_data_df['Alpha'].values\n", - "polar_cl = airfoil_data_df['Cl'].values\n", - "polar_cd = airfoil_data_df['Cd'].values\n", - "\n", - "airfoil = Airfoil(alpha, polar_cl, polar_cd)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "phi_0 63.43494882292202\n", - "phi_N 45.0\n" - ] - } - ], - "source": [ - "################################################################################\n", - "\n", - "# Create propeller parameters\n", - "J = 0.5\n", - "D = 1.0\n", - "N_b = 8\n", - "\n", - "def solidity(r):\n", - " NUM = 2.0 * pi * r * D \n", - " DEN = N_b * propeller.chord(r)\n", - " return NUM / DEN\n", - "\n", - "def tan_phi(r):\n", - " return J / r\n", - "\n", - "# Create distributions\n", - "N = 50\n", - "# r_hat = r / D\n", - "r_hat = np.linspace(0.25, 0.5, N)\n", - "chord = np.linspace(1.0, 0.5, N)\n", - "\n", - "tan0 = np.rad2deg(np.arctan(tan_phi(r_hat[0])))\n", - "tanN = np.rad2deg(np.arctan(tan_phi(r_hat[-1])))\n", - "\n", - "print('phi_0', tan0)\n", - "print('phi_N', tanN)\n", - "\n", - "twist = np.linspace(tan0, tanN, N) * 1.2\n", - "\n", - "propeller = Propeller(r_hub = 0.0, \n", - " r_tip = 0.0,\n", - " r_dist = r_hat,\n", - " beta_dist = twist,\n", - " chord_dist = chord)" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [], - "source": [ - "################################################################################\n", - "def residual(theta, r):\n", - "\n", - " _S = solidity(r)\n", - " \n", - " # Compute base effective pitch\n", - " _tan_phi = tan_phi(r) \n", - " phi0 = np.rad2deg(np.arctan(_tan_phi))\n", - "\n", - " # Compute airfoil angle\n", - " _twist = propeller.beta(r)\n", - " _alpha = _twist - (phi0 + theta)\n", - " \n", - " # return phi0, _alpha, _twist\n", - "\n", - " try:\n", - " _cl = airfoil.cl(_alpha)\n", - " _cd = airfoil.cd(_cl)\n", - " except:\n", - " print('phi0:', phi0)\n", - " print('twist:', _twist)\n", - " print('alpha:', _alpha)\n", - " print('theta:', theta)\n", - " raise ValueError\n", - "\n", - " _tan_gamma = _cd / _cl\n", - "\n", - " # Get angles in the right degrees\n", - " _theta = np.deg2rad(theta)\n", - " _phi = np.deg2rad(phi0 + theta)\n", - "\n", - " NUM = 1.0 - _tan_gamma * np.tan(_theta)\n", - " DEN = 4.0 * np.sin(_phi) * np.tan(_theta)\n", - "\n", - " return _S / _cl - NUM / DEN " - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e25ec2a4409a44f699d2bddb016ceeda", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "inference_angles = []\n", - "\n", - "for radius in tqdm(r_hat):\n", - " _residual = partial(residual, r = radius)\n", - " inference_angles.append({'r': radius, 'theta': newton_krylov(_residual, 0.5, iter = 1000).item()})\n", - "\n", - "theta_df = pd.DataFrame(inference_angles).set_index('r') " - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "theta_df = pd.DataFrame(inference_angles).set_index('r')\n", - "\n", - "theta_df.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [], - "source": [ - "def angles_distribution(theta, r):\n", - "\n", - " _S = solidity(r)\n", - " \n", - " # Compute base effective pitch\n", - " _tan_phi = tan_phi(r) \n", - " phi0 = np.rad2deg(np.arctan(_tan_phi))\n", - "\n", - " # Compute airfoil angle\n", - " _twist = propeller.beta(r)\n", - " _alpha = _twist - (phi0 + theta)\n", - "\n", - " _cl = airfoil.cl(_alpha)\n", - " _cd = airfoil.cd(_cl)\n", - "\n", - " _tan_gamma = _cd / _cl\n", - " _gamma = np.rad2deg(np.arctan(_tan_gamma))\n", - "\n", - " # Get angles in the right degrees\n", - " _phi = phi0 + theta\n", - "\n", - " return {'twist': _twist, \n", - " 'alpha':_alpha, \n", - " 'phi0': phi0, \n", - " 'phi': _phi, \n", - " 'r': r, \n", - " 'theta': theta, \n", - " 'S_cl': _S / _cl, \n", - " 'gamma': _gamma}\n", - "\n", - "#%%\n", - "distributions = []\n", - "\n", - "for radius in theta_df.index:\n", - " distributions.append(angles_distribution(theta_df.loc[radius].values[0], radius))\n", - "\n", - "distributions_df = pd.DataFrame(distributions)\n", - "distributions_df = distributions_df.set_index('r')\n", - "#%%" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ,\n", - " ],\n", - " dtype=object)" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "distributions_df.plot(subplots=True, figsize = (10,15))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [], - "source": [ - "from numpy import tan" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [], - "source": [ - "def incidence_axial(angles):\n", - " \n", - " phi = np.deg2rad(angles['phi'])\n", - " phi0 = np.deg2rad(angles['phi0'])\n", - " gamma = np.deg2rad(angles['gamma'])\n", - " \n", - " NUM = tan(phi) * (1.0 + tan(phi0) * tan(phi + gamma))\n", - " DEN = tan(phi0) * (1.0 + tan(phi) * tan(phi + gamma))\n", - " \n", - " return NUM / DEN - 1.0" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [], - "source": [ - "def incidence_radial(angles):\n", - " \n", - " phi = np.deg2rad(angles['phi'])\n", - " phi0 = np.deg2rad(angles['phi0'])\n", - " \n", - " a = incidence_axial(angles)\n", - " \n", - " NUM = tan(phi0) * (1.0 + a)\n", - " DEN = tan(phi)\n", - " \n", - " return 1.0 - NUM / DEN" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [], - "source": [ - "incidences = []\n", - "\n", - "for angles in distributions:\n", - "\n", - " a = incidence_axial(angles)\n", - " a_prime = incidence_radial(angles)\n", - " \n", - " incidences.append({'a':a, 'a_p': a_prime, 'r': angles['r']})" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([,\n", - " ],\n", - " dtype=object)" - ] - }, - "execution_count": 67, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "pd.DataFrame(incidences).set_index('r').plot(subplots=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [], - "source": [ - "def K(angles):\n", - " \n", - " _cl = airfoil.cl(angles['alpha'])\n", - " a = incidence_axial(angles)\n", - " \n", - " phi = np.deg2rad(angles['phi'])\n", - " gamma = np.deg2rad(angles['gamma'])\n", - " \n", - " NUM = _cl * (1.0 + a)**2.0\n", - " DEN = np.sin(phi)**2.0 * np.cos(gamma)\n", - " \n", - " return NUM / DEN" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [], - "source": [ - "def Tc(angles):\n", - " \n", - " _K = K(angles)\n", - " \n", - " phi = np.deg2rad(angles['phi'])\n", - " gamma = np.deg2rad(angles['gamma'])\n", - " \n", - " return _K * np.cos(phi + gamma)" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": {}, - "outputs": [], - "source": [ - "def Qc(angles):\n", - " \n", - " _K = K(angles)\n", - " \n", - " phi = np.deg2rad(angles['phi'])\n", - " gamma = np.deg2rad(angles['gamma'])\n", - " \n", - " return _K * np.sin(phi + gamma)" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [], - "source": [ - "def dCT_dr(angles):\n", - " \n", - " _r = angles['r']\n", - " \n", - " _c = propeller.chord(_r)\n", - " \n", - " _Tc = Tc(angles)\n", - " \n", - " return _c * _Tc" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [], - "source": [ - "def dCQ_dr(angles):\n", - " \n", - " _r = angles['r']\n", - " \n", - " _c = propeller.chord(_r)\n", - " \n", - " _Qc = Qc(angles)\n", - " \n", - " return _r * _c * _Qc" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.20220748734062266" - ] - }, - "execution_count": 73, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dCT_dr(angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.13936514558107332" - ] - }, - "execution_count": 74, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dCQ_dr(angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "93e85322ebd84b1d8c123e41fb9d1455", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=50), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "d_ct = pd.Series()\n", - "d_qt = pd.Series()\n", - "\n", - "for angles in tqdm(distributions):\n", - " d_ct.loc[angles['r']] = dCT_dr(angles)\n", - " d_qt.loc[angles['r']] = dCQ_dr(angles)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 76, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "d_ct.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "d_qt.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": {}, - "outputs": [], - "source": [ - "from scipy.integrate import simps\n" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "metadata": {}, - "outputs": [], - "source": [ - "T = pd.Series()\n", - "Q = pd.Series()\n", - "\n", - "for element in d_ct.index:\n", - " T.loc[element] = simps(d_ct.loc[:element].values, d_ct.loc[:element].index.values)\n", - " Q.loc[element] = simps(d_qt.loc[:element].values, d_qt.loc[:element].index.values)" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 80, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "T.plot()\n", - "Q.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.032213533689808706" - ] - }, - "execution_count": 82, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "T.tail(1).values[0]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "pybem", - "language": "python", - "name": "pybem" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.9" - }, - "latex_envs": { - "LaTeX_envs_menu_present": true, - "autoclose": false, - "autocomplete": true, - "bibliofile": "biblio.bib", - "cite_by": "apalike", - "current_citInitial": 1, - "eqLabelWithNumbers": true, - "eqNumInitial": 1, - "hotkeys": { - "equation": "Ctrl-E", - "itemize": "Ctrl-I" - }, - "labels_anchors": false, - "latex_user_defs": false, - "report_style_numbering": false, - "user_envs_cfg": false - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": false, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": false - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/src/pybem/bem/model.py b/src/pybem/bem/model.py index a267620..48fb708 100644 --- a/src/pybem/bem/model.py +++ b/src/pybem/bem/model.py @@ -2,6 +2,7 @@ from math import pi import numpy as np +from scipy.integrate import simps as integrate from scipy.optimize import newton_krylov from .loss import compute_hub_loss, compute_tip_loss @@ -26,17 +27,21 @@ class BladeElementMethod: ---------- J : float Advance ratio. - propeller - flight + propeller : Propeller-like object + flight : FlightConditions-like object tip_loss : bool + Use the tip correction factor? Default is `False`. hub_loss : bool + Use the tip correction factor? Default is `False`. r_dist : list of floats phi : list of floats - C_T : np.array - C_Q : np.array + C_T : list of floats + C_Q : list of floats + N_SECTIONS : int + EPSILON : float """ - N_SECTIONS = 10 + N_SECTIONS = 100 EPSILON = 1e-6 def __init__(self, J, propeller, flight=None, tip_loss=False, hub_loss=False): @@ -50,36 +55,192 @@ def __init__(self, J, propeller, flight=None, tip_loss=False, hub_loss=False): self.hub_loss = hub_loss # Dimensionless thrust and torque distribution - self.phi = [] - self.C_T = None - self.C_Q = None + self.r_dist = [] + self.phi_dist = [] + self.a_dist = [] + self.b_dist = [] + self.F_dist = [] + self.dCTdr_dist = [] + self.dCQdr_dist = [] + + self.CT = None + self.CQ = None + + @staticmethod + def compute_ct(cl, cd, phi): + """Compute section tangential force coefficient. + + Parameters + ---------- + cl : float + cd : float + phi : float + Incidence angle in degrees. + + Returns + ------- + ct : float + """ + + phi = np.deg2rad(phi) + + ct = cl * np.cos(phi) - cd * np.sin(phi) + + return ct + + @staticmethod + def compute_cn(cl, cd, phi): + """Compute section angular force coefficient. + + Parameters + ---------- + cl : float + cd : float + phi : float + Incidence angle in degrees. + + Returns + ------- + cn : float + """ + + phi = np.deg2rad(phi) + + cn = cl * np.sin(phi) + cd * np.cos(phi) + + return cn + + @staticmethod + def force_coeff_integrand(r, F, a): + """Compute the slope dCT/dr to integrate CT. + + Parameters + ---------- + r : float + F : float + a : float + + Returns + ------- + dCTdr : float + """ + + dCTdr = 8.0 * pi * r * (1.0 + a) * a * F + + return dCTdr + + @staticmethod + def torque_coeff_integrand(r, F, a, b, J): + """Compute the slope dCT/dr to integrate CT. + + Parameters + ---------- + r : float + F : float + a : float + b : float + J : float + + Returns + ------- + dCQdr : float + """ + + dCQdr = 8.0 * pi * (r ** 3.0) * (1.0 + a) * b * F / J + + return dCQdr def solve(self): - """Solve the BEM""" + """Solve the Blade Element Problem + + Returns + ------- + r_dist : array-like of floats + Dimensionless radii. + phi : array-like of floats + Incidence angles for each r. + """ r_min = self.propeller.radii[0] # Create dimensionless radius distribution - start = r_min * (1.0 + self.EPSILON) - stop = 1.0 - self.EPSILON + # Take into account when losses are actived we cannot solve at the exact section + start = r_min if self.hub_loss == False else r_min * (1.0 + self.EPSILON) + stop = 1.0 if self.tip_loss == False else 1.0 - self.EPSILON + r_dist = np.linspace(start=start, stop=stop, num=self.N_SECTIONS) + self.r_dist = r_dist phi0 = self.propeller.compute_beta(r_min) phi = [] + a = [] + b = [] + dCTdr = [] + dCQdr = [] + F = [] for r in r_dist: + # (BEM loop) # Solve inflow angle. _phi = self.compute_inflow_angle(r=r, phi0=phi0) + # Save station value phi.append(_phi) + # Update starting point for the next iteration phi0 = _phi - self.phi = phi - self.r_dist = r_dist + # (Performance calculation loop) + # Compute differential force and torque slopes + _F = self.compute_prandtl_loss(r=r, phi=_phi) + _a, _b = self.compute_induction_coefficients(r=r, phi=_phi) + + _dCTdr = self.force_coeff_integrand(r=r, a=_a, F=_F) + _dCQdr = self.torque_coeff_integrand(r=r, a=_a, F=_F, b=_b, J=self.J) + + # Save station values + F.append(_F) + dCTdr.append(_dCTdr) + dCQdr.append(_dCQdr) + a.append(_a) + b.append(_b) + + self.phi_dist = phi + self.F_dist = F + self.dCTdr_dist = dCTdr + self.dCQdr_dist = dCQdr + self.a_dist = a + self.b_dist = b return r_dist, phi + def integrate_forces(self): + """Integrate thrust and torque distributions. + + Returns + ------- + CT : float + CQ : float + + Notes + ----- + Uses `self` variables: + - r_dist + - dCTdr_dist + - dCQdr_dist + """ + + # Creates integrator based on the radius distribution + _integrate = partial(integrate, x=self.r_dist) + + CT = _integrate(self.dCTdr_dist) + CQ = _integrate(self.dCQdr_dist) + + self.CT = CT + self.CQ = CQ + + return CT, CQ + def _residual(self, phi, r): """Nonlinear inflow angle equation residual. @@ -97,6 +258,39 @@ def _residual(self, phi, r): residual : float """ + # Compute angle of attack + a, b = self.compute_induction_coefficients(r=r, phi=phi) + + # Compute residual + J = self.J + + phi = np.deg2rad(phi) + + SUM_1 = np.sin(phi) / (1.0 + a) + SUM_2 = J * np.cos(phi) / (r * (1.0 - b)) + + res = SUM_1 - SUM_2 + + return res + + def compute_induction_coefficients(self, r, phi): + """Compute the velocity induction coefficients. + + Parameters + ---------- + r : float + Dimensionless coefficients. + phi : float + Incidence angle in degrees. + + Returns + ------- + a : float + Axial induction coefficient. + b : float + Tangential induction coefficient. + """ + propeller = self.propeller # Compute angle of attack @@ -113,17 +307,7 @@ def _residual(self, phi, r): a = self.compute_axial_coefficient(r=r, phi=phi, cl=cl, cd=cd, sigma=sigma) b = self.compute_angular_coefficient(r=r, phi=phi, cl=cl, cd=cd, sigma=sigma) - # Compute residual - J = self.J - - phi = np.deg2rad(phi) - - SUM_1 = np.sin(phi) / (1.0 + a) - SUM_2 = J * np.cos(phi) / (r * (1.0 - b)) - - res = SUM_1 - SUM_2 - - return res + return a, b def compute_prandtl_loss(self, r, phi): """Compute tip and hub losses according to the Prandtl model. @@ -159,50 +343,6 @@ def compute_prandtl_loss(self, r, phi): return F - @staticmethod - def compute_ct(cl, cd, phi): - """Compute section tangential force coefficient. - - Parameters - ---------- - cl : float - cd : float - phi : float - Incidence angle in degrees. - - Returns - ------- - ct : float - """ - - phi = np.deg2rad(phi) - - ct = cl * np.cos(phi) - cd * np.sin(phi) - - return ct - - @staticmethod - def compute_cn(cl, cd, phi): - """Compute section angular force coefficient. - - Parameters - ---------- - cl : float - cd : float - phi : float - Incidence angle in degrees. - - Returns - ------- - cn : float - """ - - phi = np.deg2rad(phi) - - cn = cl * np.sin(phi) + cd * np.cos(phi) - - return cn - def compute_axial_coefficient(self, r, phi, cl, cd, sigma): ct = self.compute_ct(cl=cl, cd=cd, phi=phi) @@ -276,86 +416,3 @@ def compute_inflow_angle(self, r, phi0=0.0): # phi = np.array(np.nan) return phi.item() - - def compute_loads(self, dr=0.01): - """Compute blade loads. - - Parameters - ---------- - dr: float - Spacing between stations. - - Returns - ------- - tuple: thrust, torque - - """ - _J = self.J - _D = self.D - - _r_hub = self.propeller.r_hub / _D - _r_tip = self.propeller.r_tip / _D - - # Number of steps - N = np.floor((_r_tip - _r_hub) / dr) - - # Create nondimensional radius distribution - r_space = np.linspace(start=_r_hub, stop=_r_tip, num=N) - - # Initial condition - C_T = [0.0] - C_Q = [0.0] - - # Initial condition is 20% larger than the twist angle - phi0 = np.arctan(_J / _r_hub) - phi0 = np.rad2deg(phi0) - - phi_space = [phi0] - F_space = [1.0] - - idx = 0 # Index to control numpy arrays - for r in r_space[:-1]: - - # Compute induction angle - phi = self.compute_inflow_angle(r, phi_space[idx]) - - # Compute induction coefficients - axi = self.compute_axial_coefficient(r, phi, self.beta) - tng = self.compute_cn(r, phi, self.beta) - - # Tip loss - _F = self.compute_tip_loss(r, phi) - - # Compute Euler **implicit** derivative - F_T = 4.0 * pi * _J ** 2.0 * (r + dr) ** 1.0 * (1.0 + axi) * axi * _F - F_Q = 4.0 * pi * _J ** 1.0 * (r + dr) ** 3.0 * (1.0 + axi) * tng * _F - - # Integrate - C_T.append(C_T[idx] + dr * F_T) - C_Q.append(C_Q[idx] + dr * F_Q) - - # Save state - F_space.append(_F) - phi_space.append(phi) - - idx += 1 - - C_T = np.array(C_T) - C_Q = np.array(C_Q) - - self.C_T = C_T - self.C_Q = C_Q - - self.dr = dr - self.N = N - - # Pack up results - result = dict() - - result["r"] = r_space - result["C_T"] = C_T - result["C_Q"] = C_Q - result["F"] = F_space - result["phi"] = phi_space - - return result diff --git a/tests/_test_no_tip_loss.py b/tests/_test_no_tip_loss.py deleted file mode 100644 index c672cf7..0000000 --- a/tests/_test_no_tip_loss.py +++ /dev/null @@ -1,52 +0,0 @@ -from math import pi - -import numpy as np -import pandas as pd - -from pybem import BladeElementMethod - - -def get_polar(): - # Read and parse polar - polar_df = pd.read_csv(r"pybem\data\naca2415.csv") - polar_df = polar_df.set_index("Alpha")[["Cl", "Cd"]] - - # Extract numpy arrays - alpha = polar_df.index.values - cl_alpha = polar_df["Cl"].values - cd_polar = polar_df["Cd"].values - - return alpha, cl_alpha, cd_polar - - -bem = BladeElementMethod() - -# Polar -alpha, cl_alpha, cd_polar = get_polar() - -# Lenghts -D = 0.152 * 2 # meters -r_tip = D / 2.0 -r_hub = r_tip * 0.15 - -# Propeller -# --------------------------------- -r = np.linspace(r_hub, r_tip) -_r = r / r_tip -beta = np.linspace(50, 20, 50) -chord = (1.1 - _r ** 4.0 * np.exp(_r - 1)) * r -# --------------------------------- - -# Load data -bem.load_airfoil(alpha, cl_alpha, cd_polar) - -J = 0.1 -bem.load_similarity(J=J) - -# bem.load_flight_conditions(V_inf, omega, altitude = 10000) -prop = bem.load_propeller(dist_r=r, dist_beta=beta, dist_chord=chord, n_blades=4) -bem.set_tip_loss(False) - -loads = bem.compute_loads(dr=0.01) - -assert loads["C_T"][-1] > 0 diff --git a/tests/_test_tip_loss.py b/tests/_test_tip_loss.py deleted file mode 100644 index edbdb45..0000000 --- a/tests/_test_tip_loss.py +++ /dev/null @@ -1,52 +0,0 @@ -from math import pi - -import numpy as np -import pandas as pd - -from pybem import BladeElementMethod - - -def get_polar(): - # Read and parse polar - polar_df = pd.read_csv(r"pybem\data\naca2415.csv") - polar_df = polar_df.set_index("Alpha")[["Cl", "Cd"]] - - # Extract numpy arrays - alpha = polar_df.index.values - cl_alpha = polar_df["Cl"].values - cd_polar = polar_df["Cd"].values - - return alpha, cl_alpha, cd_polar - - -bem = BladeElementMethod() - -# Polar -alpha, cl_alpha, cd_polar = get_polar() - -# Lenghts -D = 0.152 * 2 # meters -r_tip = D / 2.0 -r_hub = r_tip * 0.15 - -# Propeller -# --------------------------------- -r = np.linspace(r_hub, r_tip) -_r = r / r_tip -beta = np.linspace(50, 20, 50) -chord = (1.1 - _r ** 4.0 * np.exp(_r - 1)) * r -# --------------------------------- - -# Load data -bem.load_airfoil(alpha, cl_alpha, cd_polar) - -J = 0.1 -bem.load_similarity(J=J) - -# bem.load_flight_conditions(V_inf, omega, altitude = 10000) -prop = bem.load_propeller(dist_r=r, dist_beta=beta, dist_chord=chord, n_blades=4) -bem.set_tip_loss(True) - -loads = bem.compute_loads(dr=0.01) - -assert loads["C_T"][-1] > 0 diff --git a/tests/bem/test_model.py b/tests/bem/test_model.py index ec034cf..929ad44 100644 --- a/tests/bem/test_model.py +++ b/tests/bem/test_model.py @@ -40,25 +40,25 @@ def propeller(): return propeller -def test_run_bem_no_losses(propeller): +class TestRun: + def test_no_losses(self, propeller): - bem = BladeElementMethod(J=1, propeller=propeller) + bem = BladeElementMethod(J=1, propeller=propeller) - bem.solve() + bem.solve() - pass # What could I assert? + pass # What could I assert? + def test_with_losses(self, propeller): -def test_run_bem_with_losses(propeller): + bem = BladeElementMethod(J=1, propeller=propeller, tip_loss=True, hub_loss=True) - bem = BladeElementMethod(J=1, propeller=propeller, tip_loss=True, hub_loss=True) + bem.solve() - bem.solve() + pass # What could I assert? - pass # What could I assert? - -def test_reproduce_bem_no_losses(propeller): +class TestReproduceOutputs: """This is not a proper test, but it gives you some guarantees. With the actual state of the code, we are getting a result that seems @@ -73,66 +73,86 @@ def test_reproduce_bem_no_losses(propeller): need to be updated. """ - bem = BladeElementMethod(J=1, propeller=propeller) + J = 0.2 - bem.N_SECTIONS = 10 + def test_solve_no_losses(self, propeller): - bem.solve() + bem = BladeElementMethod(J=self.J, propeller=propeller) - result_phi = bem.phi + bem.N_SECTIONS = 10 - expected_phi = [ - 65.02457613402427, - 61.53158664709961, - 58.06287232558151, - 54.680737977050924, - 52.70649811115369, - 50.648517749244384, - 48.57169404768725, - 46.52659452619687, - 44.549823308619374, - 42.66534592922986, - ] + bem.solve() - assert_allclose(expected_phi, result_phi) + result_phi = bem.phi_dist + expected_phi = [ + 53.7559900627035, + 46.51360450433435, + 40.24566201204451, + 34.82356412209791, + 31.020411856568106, + 27.60175003439307, + 24.517814495030052, + 21.727980253100842, + 19.200977399649037, + 16.913981930219638, + ] -def test_reproduce_bem_with_losses(propeller): - """This is not a proper test, but it gives you some guarantees. + assert_allclose(expected_phi, result_phi) - With the actual state of the code, we are getting a result that seems - to be correct for the type of phenomena we are solving. + def test_solve_with_losses(self, propeller): - Perhaps if we linearise the equations we could validate the solver, but - I haven't had time for the moment. So I check at least that for the same inputs, - I am getting the same outputs from here on. + bem = BladeElementMethod( + J=self.J, propeller=propeller, tip_loss=True, hub_loss=True + ) - If a bug is found in the future, this test would fail, but that is not - necessarilly wrong. If the bug is proved to be correct, then the expected values - need to be updated. - """ + bem.N_SECTIONS = 10 - bem = BladeElementMethod(J=1, propeller=propeller, tip_loss=True, hub_loss=True) + bem.solve() - bem.solve() + result_phi = bem.phi_dist - bem.N_SECTIONS = 10 + expected_phi = [ + 59.98375776054978, + 47.80654198333023, + 40.79851063596392, + 35.07657290878467, + 31.187956608585395, + 27.78122466482189, + 24.817388223831337, + 22.331258522446035, + 20.59650318210961, + 29.83229695496505, + ] - bem.solve() + assert_allclose(expected_phi, result_phi) - result_phi = bem.phi + def test_forces_no_losses(self, propeller): - expected_phi = [ - 60.011868623160844, - 60.2642555093087, - 57.29588901630371, - 54.09221438071569, - 52.18007160086735, - 50.04596910839645, - 47.76712196831369, - 45.351112313287835, - 42.5933251947877, - 30.13349622416542, - ] + bem = BladeElementMethod( + J=self.J, propeller=propeller, tip_loss=False, hub_loss=False + ) + + bem.solve() + + CT, CQ = bem.integrate_forces() + + result_forces = [CT, CQ] + expected_forces = [9.448702260173416, 3.198004953641942] + + assert_allclose(expected_forces, result_forces) + + def test_forces_with_losses(self, propeller): + + bem = BladeElementMethod( + J=self.J, propeller=propeller, tip_loss=True, hub_loss=True + ) + + bem.solve() + + CT, CQ = bem.integrate_forces() + + result_forces = [CT, CQ] + expected_forces = [8.633726487035544, 3.0419449911253316] - assert_allclose(expected_phi, result_phi) \ No newline at end of file + assert_allclose(expected_forces, result_forces) \ No newline at end of file