summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--__init__.py4
-rw-r--r--creator.py869
-rw-r--r--evaluator.py20
-rw-r--r--main.py56
4 files changed, 509 insertions, 440 deletions
diff --git a/__init__.py b/__init__.py
index 5e916af..dc031d0 100644
--- a/__init__.py
+++ b/__init__.py
@@ -13,5 +13,5 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
__author__ = "Marius Peter"
-__version__ = "2.3"
-__revision__ = "2.3.1"
+# __version__ = "2.3"
+# __revision__ = "2.3.1"
diff --git a/creator.py b/creator.py
index eac3918..634277e 100644
--- a/creator.py
+++ b/creator.py
@@ -1,422 +1,447 @@
-# This file is part of Marius Peter's airfoil analysis package (this program).
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-import sys
-import os.path
-import numpy as np
-from math import sin, cos, tan, atan, sqrt, ceil
-import bisect as bi
-import matplotlib.pyplot as plt
-import matplotlib as mpl
-from mpl_toolkits.mplot3d import Axes3D
-
-# This variable is required for main.py constant wing dimensions
-# to be passed to inheriting classes (Airfoil, Spar, Stringer, Rib).
-# This way, we don't have to redeclare our coordinates as parameters for
-# our spars, stringers and ribs. This makes for more elegant code.
-global parent
-
-
-class Coordinates:
- """
- All airfoil components need the following:
-
- Parameters:
- * Component material
- * Coordinates relative to the chord & semi-span.
-
- Methods:
- * Print component coordinates
- * Save component coordinates to file specified in main.py
-
- So, all component classes inherit from class Coordinates.
- """
-
- def __init__(self, chord, semi_span):
- # Global dimensions
- self.chord = chord
- if chord < 10:
- self.chord = 10
- self.semi_span = semi_span
- # Component material
- self.material = str()
- # Upper coordinates
- self.x_u = []
- self.y_u = []
- # Lower coordinates
- self.x_l = []
- self.y_l = []
- # Coordinates x_u, y_u, x_l, y_l packed in single list
- self.coord = []
- # The airfoil components know the Coordinates instance's coords
- global parent
- parent = self
-
- def __str__(self):
- return type(self).__name__
-
- def print_coord(self, round):
- """
- Print all the component's coordinates to the terminal.
-
- This function's output is piped to the 'save_coord' function below.
- """
- print('============================')
- print('Component:', str(self))
- print('Chord length:', self.chord)
- print('Semi-span:', self.semi_span)
- print('============================')
- print('x_u the upper x-coordinates:\n', np.around(self.x_u, round))
- print('y_u the upper y-coordinates:\n', np.around(self.y_u, round))
- print('x_l the lower x-coordinates:\n', np.around(self.x_l, round))
- print('y_l the lower y-coordinates:\n', np.around(self.y_l, round))
- # print('\n')
- return None
-
- def save_coord(self, save_dir_path, number):
- """
- Save all the object's coordinates (must be full path).
- """
-
- file_name = '{}_{}.txt'.format(self, number)
- full_path = os.path.join(save_dir_path, file_name)
- # sys.stdout = open(full_path, 'w')
- # self.print_coord(2)
- with open(full_path, 'w') as sys.stdout:
- self.print_coord(2)
- # Following line required to reset value of sys.stdout
- sys.stdout = sys.__stdout__
- # It is cleaner to use this context guard to ensure file is closed
-
- return None
-
- def pack_coord(self):
- self.coord.append(self.x_u)
- self.coord.append(self.y_u)
- self.coord.append(self.x_l)
- self.coord.append(self.y_l)
-
-
-class Airfoil(Coordinates):
- """This class enables the creation of a single NACA airfoil."""
-
- def __init__(self):
- global parent
- # Run 'Coordinates' super class init method with same chord & 1/2 span.
- super().__init__(parent.chord, parent.semi_span)
- # NACA number
- self.naca_num = int()
- # Mean camber line
- self.x_c = [] # Contains only integers from 0 to self.chord
- self.y_c = [] # Contains floats
- # Thickness
- self.y_t = []
- # dy_c / d_x
- self.dy_c = []
- # Theta
- self.theta = []
-
- def add_naca(self, naca_num):
- """
- This function generates geometry for our chosen NACA airfoil shape.
- The nested functions perform the required steps to generate geometry,
- and can be called to solve the geometry y-coordinate for any 'x' input.
- Equation coefficients were retrieved from Wikipedia.org.
-
- Parameters:
- naca_num: 4-digit NACA wing
-
- Return:
- None
- """
-
- # Variables extracted from 'naca_num' argument passed to the function
- self.naca_num = naca_num
- m = int(str(naca_num)[0]) / 100
- p = int(str(naca_num)[1]) / 10
- t = int(str(naca_num)[2:]) / 100
- # x-coordinate of maximum camber
- p_c = p * self.chord
-
- def get_camber(x):
- """
- Returns 1 camber y-coordinate from 1 'x' along the airfoil chord.
- """
- x_c = x
- y_c = float()
- if 0 <= x < p_c:
- y_c = (m / (p**2)) * (2 * p * (x / self.chord) -
- (x / self.chord)**2)
- elif p_c <= x <= self.chord:
- y_c = (m /
- ((1 - p)**2)) * ((1 - 2 * p) + 2 * p *
- (x / self.chord) - (x / self.chord)**2)
- else:
- print('x-coordinate for camber is out of bounds. '
- 'Check that 0 < x <= chord.')
- return (x_c, y_c * self.chord)
-
- def get_thickness(x):
- """
- Returns thickness from 1 'x' along the airfoil chord.
- """
- y_t = float()
- if 0 <= x <= self.chord:
- y_t = 5 * t * self.chord * (0.2969 * sqrt(x / self.chord) -
- 0.1260 *
- (x / self.chord) - 0.3516 *
- (x / self.chord)**2 + 0.2843 *
- (x / self.chord)**3 - 0.1015 *
- (x / self.chord)**4)
- else:
- print('x-coordinate for thickness is out of bounds. '
- 'Check that 0 < x <= chord.')
- return y_t
-
- def get_dy_c(x):
- """
- Returns dy_c/dx from 1 'x' along the airfoil chord.
- """
- dy_c = float()
- if 0 <= x < p_c:
- dy_c = ((2 * m) / p**2) * (p - x / self.chord)
- elif p_c <= x <= self.chord:
- dy_c = (2 * m) / ((1 - p)**2) * (p - x / self.chord)
- return dy_c
-
- def get_theta(dy_c):
- theta = atan(dy_c)
- return theta
-
- def get_upper_coordinates(x):
- x_u = float()
- y_u = float()
- if 0 <= x < self.chord:
- x_u = x - self.y_t[x] * sin(self.theta[x])
- y_u = self.y_c[x] + self.y_t[x] * cos(self.theta[x])
- elif x == self.chord:
- x_u = x - self.y_t[x] * sin(self.theta[x])
- y_u = 0 # Make upper curve finish at y = 0
- return (x_u, y_u)
-
- def get_lower_coordinates(x):
- x_l = float()
- y_l = float()
- if 0 <= x < self.chord:
- x_l = (x + self.y_t[x] * sin(self.theta[x]))
- y_l = (self.y_c[x] - self.y_t[x] * cos(self.theta[x]))
- elif x == self.chord:
- x_l = (x + self.y_t[x] * sin(self.theta[x]))
- y_l = 0 # Make lower curve finish at y = 0
- return (x_l, y_l)
-
- # Generate all our wing geometries from previous sub-functions
- for x in range(0, self.chord + 1):
- self.x_c.append(get_camber(x)[0])
- self.y_c.append(get_camber(x)[1])
- self.y_t.append(get_thickness(x))
- self.dy_c.append(get_dy_c(x))
- self.theta.append(get_theta(self.dy_c[x]))
- self.x_u.append(get_upper_coordinates(x)[0])
- self.y_u.append(get_upper_coordinates(x)[1])
- self.x_l.append(get_lower_coordinates(x)[0])
- self.y_l.append(get_lower_coordinates(x)[1])
-
- super().pack_coord()
- return None
-
-
-class Spar(Coordinates):
- """Contains a single spar's location."""
- global parent
-
- def __init__(self):
- super().__init__(parent.chord, parent.semi_span)
-
- def add(self, airfoil_coord, spar_x):
- """
- Add a single spar at the % chord location given to function.
-
- Parameters:
- coordinates: provided by Airfoil.coordinates[x_u, y_u, x_l, y_l].
- material: spar's material. Assumes homogeneous material.
- spar_x: spar's location as a % of total chord length.
-
- Return:
- None
- """
- # Airfoil surface coordinates
- # unpacked from 'coordinates' (list of lists in 'Coordinates').
- x_u = airfoil_coord[0]
- y_u = airfoil_coord[1]
- x_l = airfoil_coord[2]
- y_l = airfoil_coord[3]
- # Scaled spar location with regards to chord
- loc = spar_x * self.chord
- # bisect_left: returns index of first value in x_u > loc.
- # This ensures that the spar coordinates intersect with airfoil surface.
- spar_x_u = bi.bisect_left(x_u, loc) # index of spar's x_u
- spar_x_l = bi.bisect_left(x_l, loc) # index of spar's x_l
- # These x and y coordinates are assigned to the spar, NOT airfoil.
- self.x_u.append(x_u[spar_x_u])
- self.y_u.append(y_u[spar_x_u])
- self.x_l.append(x_l[spar_x_l])
- self.y_l.append(y_l[spar_x_l])
-
- super().pack_coord()
- return None
-
-
-class Stringer(Coordinates):
- """Contains the coordinates of all stringers."""
- global parent
-
- def __init__(self):
- super().__init__(parent.chord, parent.semi_span)
-
- def add(self, airfoil_coord, spar_coord, stringer_u_1, stringer_u_2,
- stringer_l_1, stringer_l_2):
- """
- Add equally distributed stringers to four airfoil locations
- (upper nose, lower nose, upper surface, lower surface).
-
- Parameters:
- stringer_u_1: upper nose number of stringers
- stringer_u_2: upper surface number of stringers
- stringer_l_1: lower nose number of stringers
- stringer_l_2: lower surface number of stringers
-
- Returns:
- None
- """
-
- # Airfoil surface coordinates
- # unpacked from 'coordinates' (list of lists in 'Coordinates').
- airfoil_x_u = airfoil_coord[0]
- airfoil_y_u = airfoil_coord[1]
- airfoil_x_l = airfoil_coord[2]
- airfoil_y_l = airfoil_coord[3]
- # Spar coordinates
- # unpacked from 'coordinates' (list of lists in 'Coordinates').
- try:
- spar_x_u = spar_coord[0]
- spar_y_u = spar_coord[1]
- spar_x_l = spar_coord[2]
- spar_y_l = spar_coord[3]
- except:
- print('Unable to initialize stringers. Were spars created?')
- # Find distance between leading edge and first upper stringer
- interval = spar_x_u[0] / (stringer_u_1 + 1)
- # initialise first self.stringer_x_u at first interval
- x = interval
- # Add upper stringers from leading edge until first spar.
- for _ in range(0, stringer_u_1):
- # Index of the first value of airfoil_x_u > x
- index = bi.bisect_left(airfoil_x_u, x)
- self.x_u.append(airfoil_x_u[index])
- self.y_u.append(airfoil_y_u[index])
- x += interval
- # Add upper stringers from first spar until last spar
- interval = (spar_x_u[-1] - spar_x_u[0]) / (stringer_u_2 + 1)
- x = interval + spar_x_u[0]
- for _ in range(0, stringer_u_2):
- index = bi.bisect_left(airfoil_x_u, x)
- self.x_u.append(airfoil_x_u[index])
- self.y_u.append(airfoil_y_u[index])
- x += interval
-
- # Find distance between leading edge and first lower stringer
- interval = spar_x_l[0] / (stringer_l_1 + 1)
- x = interval
- # Add lower stringers from leading edge until first spar.
- for _ in range(0, stringer_l_1):
- index = bi.bisect_left(airfoil_x_l, x)
- self.x_l.append(airfoil_x_l[index])
- self.y_l.append(airfoil_y_l[index])
- x += interval
- # Add lower stringers from first spar until last spar
- interval = (spar_x_l[-1] - spar_x_l[0]) / (stringer_l_2 + 1)
- x = interval + spar_x_l[0]
- for _ in range(0, stringer_l_2):
- index = bi.bisect_left(airfoil_x_l, x)
- self.x_l.append(airfoil_x_l[index])
- self.y_l.append(airfoil_y_l[index])
- x += interval
-
- super().pack_coord()
- return None
-
-
-def plot(airfoil, spar, stringer):
- """This function plots the elements passed as arguments."""
-
- print('Plotting airfoil.')
- # Plot chord
- x_chord = [0, airfoil.chord]
- y_chord = [0, 0]
- plt.plot(x_chord, y_chord, linewidth='1')
- # Plot mean camber line
- plt.plot(airfoil.x_c,
- airfoil.y_c,
- '-.',
- color='r',
- linewidth='2',
- label='mean camber line')
- # Plot upper surface
- plt.plot(airfoil.x_u, airfoil.y_u, '', color='b', linewidth='1')
- # Plot lower surface
- plt.plot(airfoil.x_l, airfoil.y_l, '', color='b', linewidth='1')
-
- # Plot spars
- try:
- for _ in range(0, len(spar.x_u)):
- x = (spar.x_u[_], spar.x_l[_])
- y = (spar.y_u[_], spar.y_l[_])
- plt.plot(x, y, '.-', color='b')
- plt.legend()
- except:
- print('Did not plot spars. Were they added?')
-
- # Plot stringers
- try:
- # Upper stringers
- for _ in range(0, len(stringer.x_u)):
- x = stringer.x_u[_]
- y = stringer.y_u[_]
- plt.plot(x, y, '.', color='y')
- # Lower stringers
- for _ in range(0, len(stringer.x_l)):
- x = stringer.x_l[_]
- y = stringer.y_l[_]
- plt.plot(x, y, '.', color='y')
- except:
- print('Unable to plot stringers. Were they created?')
-
- # Graph formatting
- plt.gcf().set_size_inches(9, 2.2)
- plt.xlabel('X axis')
- plt.ylabel('Y axis')
- # plt.gcf().set_size_inches(self.chord, max(self.y_u) - min(self.y_l))
- plt.grid(axis='both', linestyle=':', linewidth=1)
- plt.show()
- return None
-
-
-def main():
- return None
-
-
-if __name__ == '__main__':
- main()
+# This file is part of Marius Peter's airfoil analysis package (this program).
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import sys
+import os.path
+import numpy as np
+from math import sin, cos, tan, atan, sqrt, ceil
+import bisect as bi
+import matplotlib.pyplot as plt
+
+# This variable is required for main.py constant wing dimensions
+# to be passed to inheriting classes (Airfoil, Spar, Stringer, Rib).
+# This way, we don't have to redeclare our coordinates as parameters for
+# our spars, stringers and ribs. This makes for more elegant code.
+global parent
+
+
+class Coordinates:
+ """
+ All airfoil components need the following:
+
+ Parameters:
+ * Component material
+ * Coordinates relative to the chord & semi-span.
+
+ Methods:
+ * Print component coordinates
+ * Save component coordinates to file specified in main.py
+
+ So, all component classes inherit from class Coordinates.
+ """
+
+ def __init__(self, chord, semi_span):
+ # Global dimensions
+ self.chord = chord
+ if chord < 10:
+ self.chord = 10
+ self.semi_span = semi_span
+ # mass and area
+ self.mass = float()
+ self.area = float()
+ # Component material
+ self.material = str()
+ # Upper coordinates
+ self.x_u = []
+ self.z_u = []
+ # Lower coordinates
+ self.x_l = []
+ self.z_l = []
+ # Coordinates x_u, z_u, x_l, z_l packed in single list
+ self.coord = []
+
+ # The airfoil components know the Coordinates instance's coords
+ global parent
+ parent = self
+
+ def __str__(self):
+ return type(self).__name__
+
+ def print_info(self, round):
+ """
+ Print all the component's coordinates to the terminal.
+
+ This function's output is piped to the 'save_coord' function below.
+ """
+ print('============================')
+ print('Component:', str(self))
+ print('Chord length:', self.chord)
+ print('Semi-span:', self.semi_span)
+ print('Mass:', self.mass)
+ print('============================')
+ print('x_u the upper x-coordinates:\n', np.around(self.x_u, round))
+ print('z_u the upper y-coordinates:\n', np.around(self.z_u, round))
+ print('x_l the lower x-coordinates:\n', np.around(self.x_l, round))
+ print('z_l the lower y-coordinates:\n', np.around(self.z_l, round))
+ return None
+
+ def save_info(self, save_dir_path, number):
+ """
+ Save all the object's coordinates (must be full path).
+ """
+
+ file_name = '{}_{}.txt'.format(self, number)
+ full_path = os.path.join(save_dir_path, file_name)
+ try:
+ with open(full_path, 'w') as sys.stdout:
+ self.print_info(2)
+ # This line required to reset behavior of sys.stdout
+ sys.stdout = sys.__stdout__
+ print('Successfully wrote to file {}'.format(full_path))
+ except:
+ print('Unable to write {} to specified directory.\n'
+ .format(file_name),
+ 'Was the full path passed to the function?')
+ # It is cleaner to use this context guard to ensure file is closed
+ return None
+
+ def pack_info(self):
+ self.coord.append(self.x_u)
+ self.coord.append(self.z_u)
+ self.coord.append(self.x_l)
+ self.coord.append(self.z_l)
+ return None
+
+
+class Airfoil(Coordinates):
+ """This class enables the creation of a single NACA airfoil."""
+
+ def __init__(self):
+ global parent
+ # Run 'Coordinates' super class init method with same chord & 1/2 span.
+ super().__init__(parent.chord, parent.semi_span)
+ # NACA number
+ self.naca_num = int()
+ # Mean camber line
+ self.x_c = [] # Contains only integers from 0 to self.chord
+ self.y_c = [] # Contains floats
+ # Thickness
+ self.y_t = []
+ # dy_c / d_x
+ self.dy_c = []
+ # Theta
+ self.theta = []
+
+ def add_naca(self, naca_num):
+ """
+ This function generates geometry for our chosen NACA airfoil shape.
+ The nested functions perform the required steps to generate geometry,
+ and can be called to solve the geometry y-coordinate for any 'x' input.
+ Equation coefficients were retrieved from Wikipedia.org.
+
+ Parameters:
+ naca_num: 4-digit NACA wing
+
+ Return:
+ None
+ """
+
+ # Variables extracted from 'naca_num' argument passed to the function
+ self.naca_num = naca_num
+ m = int(str(naca_num)[0]) / 100
+ p = int(str(naca_num)[1]) / 10
+ t = int(str(naca_num)[2:]) / 100
+ # x-coordinate of maximum camber
+ p_c = p * self.chord
+
+ def get_camber(x):
+ """
+ Returns 1 camber y-coordinate from 1 'x' along the airfoil chord.
+ """
+ x_c = x
+ y_c = float()
+ if 0 <= x < p_c:
+ y_c = (m / (p**2)) * (2 * p * (x / self.chord) -
+ (x / self.chord)**2)
+ elif p_c <= x <= self.chord:
+ y_c = (m /
+ ((1 - p)**2)) * ((1 - 2 * p) + 2 * p *
+ (x / self.chord) - (x / self.chord)**2)
+ else:
+ print('x-coordinate for camber is out of bounds. '
+ 'Check that 0 < x <= chord.')
+ return (x_c, y_c * self.chord)
+
+ def get_thickness(x):
+ """
+ Returns thickness from 1 'x' along the airfoil chord.
+ """
+ y_t = float()
+ if 0 <= x <= self.chord:
+ y_t = 5 * t * self.chord * (0.2969 * sqrt(x / self.chord) -
+ 0.1260 *
+ (x / self.chord) - 0.3516 *
+ (x / self.chord)**2 + 0.2843 *
+ (x / self.chord)**3 - 0.1015 *
+ (x / self.chord)**4)
+ else:
+ print('x-coordinate for thickness is out of bounds. '
+ 'Check that 0 < x <= chord.')
+ return y_t
+
+ def get_dy_c(x):
+ """
+ Returns dy_c/dx from 1 'x' along the airfoil chord.
+ """
+ dy_c = float()
+ if 0 <= x < p_c:
+ dy_c = ((2 * m) / p**2) * (p - x / self.chord)
+ elif p_c <= x <= self.chord:
+ dy_c = (2 * m) / ((1 - p)**2) * (p - x / self.chord)
+ return dy_c
+
+ def get_theta(dy_c):
+ theta = atan(dy_c)
+ return theta
+
+ def get_upper_coordinates(x):
+ x_u = float()
+ z_u = float()
+ if 0 <= x < self.chord:
+ x_u = x - self.y_t[x] * sin(self.theta[x])
+ z_u = self.y_c[x] + self.y_t[x] * cos(self.theta[x])
+ elif x == self.chord:
+ x_u = x - self.y_t[x] * sin(self.theta[x])
+ z_u = 0 # Make upper curve finish at y = 0
+ return (x_u, z_u)
+
+ def get_lower_coordinates(x):
+ x_l = float()
+ z_l = float()
+ if 0 <= x < self.chord:
+ x_l = (x + self.y_t[x] * sin(self.theta[x]))
+ z_l = (self.y_c[x] - self.y_t[x] * cos(self.theta[x]))
+ elif x == self.chord:
+ x_l = (x + self.y_t[x] * sin(self.theta[x]))
+ z_l = 0 # Make lower curve finish at y = 0
+ return (x_l, z_l)
+
+ # Generate all our wing geometries from previous sub-functions
+ for x in range(0, self.chord + 1):
+ self.x_c.append(get_camber(x)[0])
+ self.y_c.append(get_camber(x)[1])
+ self.y_t.append(get_thickness(x))
+ self.dy_c.append(get_dy_c(x))
+ self.theta.append(get_theta(self.dy_c[x]))
+ self.x_u.append(get_upper_coordinates(x)[0])
+ self.z_u.append(get_upper_coordinates(x)[1])
+ self.x_l.append(get_lower_coordinates(x)[0])
+ self.z_l.append(get_lower_coordinates(x)[1])
+
+ super().pack_info()
+ return None
+
+ def add_mass(self, mass):
+ self.mass = mass
+
+
+class Spar(Coordinates):
+ """Contains a single spar's location."""
+ global parent
+
+ def __init__(self):
+ super().__init__(parent.chord, parent.semi_span)
+
+ def add_coord(self, airfoil_coord, spar_x):
+ """
+ Add a single spar at the % chord location given to function.
+
+ Parameters:
+ coordinates: provided by Airfoil.coordinates[x_u, z_u, x_l, z_l].
+ material: spar's material. Assumes homogeneous material.
+ spar_x: spar's location as a % of total chord length.
+
+ Return:
+ None
+ """
+ # Airfoil surface coordinates
+ # unpacked from 'coordinates' (list of lists in 'Coordinates').
+ x_u = airfoil_coord[0]
+ z_u = airfoil_coord[1]
+ x_l = airfoil_coord[2]
+ z_l = airfoil_coord[3]
+ # Scaled spar location with regards to chord
+ loc = spar_x * self.chord
+ # bisect_left: returns index of first value in x_u > loc.
+ # This ensures that the spar coordinates intersect with airfoil surface.
+ spar_x_u = bi.bisect_left(x_u, loc) # index of spar's x_u
+ spar_x_l = bi.bisect_left(x_l, loc) # index of spar's x_l
+ # These x and y coordinates are assigned to the spar, NOT airfoil.
+ self.x_u.append(x_u[spar_x_u])
+ self.z_u.append(z_u[spar_x_u])
+ self.x_l.append(x_l[spar_x_l])
+ self.z_l.append(z_l[spar_x_l])
+
+ super().pack_info()
+ return None
+
+ def add_mass(self, mass):
+ self.mass = len(self.x_u) * mass
+
+
+class Stringer(Coordinates):
+ """Contains the coordinates of all stringers."""
+ global parent
+
+ def __init__(self):
+ super().__init__(parent.chord, parent.semi_span)
+ self.area = float()
+
+ def add_coord(self, airfoil_coord, spar_coord,
+ stringer_u_1, stringer_u_2, stringer_l_1, stringer_l_2):
+ """
+ Add equally distributed stringers to four airfoil locations
+ (upper nose, lower nose, upper surface, lower surface).
+
+ Parameters:
+ stringer_u_1: upper nose number of stringers
+ stringer_u_2: upper surface number of stringers
+ stringer_l_1: lower nose number of stringers
+ stringer_l_2: lower surface number of stringers
+
+ Returns:
+ None
+ """
+
+ # Airfoil surface coordinates
+ # unpacked from 'coordinates' (list of lists in 'Coordinates').
+ airfoil_x_u = airfoil_coord[0]
+ airfoil_z_u = airfoil_coord[1]
+ airfoil_x_l = airfoil_coord[2]
+ airfoil_z_l = airfoil_coord[3]
+ # Spar coordinates
+ # unpacked from 'coordinates' (list of lists in 'Coordinates').
+ try:
+ spar_x_u = spar_coord[0]
+ spar_z_u = spar_coord[1]
+ spar_x_l = spar_coord[2]
+ spar_z_l = spar_coord[3]
+ except:
+ print('Unable to initialize stringers. Were spars created?')
+
+ # Find distance between leading edge and first upper stringer
+ interval = spar_x_u[0] / (stringer_u_1 + 1)
+ # initialise first self.stringer_x_u at first interval
+ x = interval
+ # Add upper stringers from leading edge until first spar.
+ for _ in range(0, stringer_u_1):
+ # Index of the first value of airfoil_x_u > x
+ index = bi.bisect_left(airfoil_x_u, x)
+ self.x_u.append(airfoil_x_u[index])
+ self.z_u.append(airfoil_z_u[index])
+ x += interval
+ # Add upper stringers from first spar until last spar
+ interval = (spar_x_u[-1] - spar_x_u[0]) / (stringer_u_2 + 1)
+ x = interval + spar_x_u[0]
+ for _ in range(0, stringer_u_2):
+ index = bi.bisect_left(airfoil_x_u, x)
+ self.x_u.append(airfoil_x_u[index])
+ self.z_u.append(airfoil_z_u[index])
+ x += interval
+
+ # Find distance between leading edge and first lower stringer
+ interval = spar_x_l[0] / (stringer_l_1 + 1)
+ x = interval
+ # Add lower stringers from leading edge until first spar.
+ for _ in range(0, stringer_l_1):
+ index = bi.bisect_left(airfoil_x_l, x)
+ self.x_l.append(airfoil_x_l[index])
+ self.z_l.append(airfoil_z_l[index])
+ x += interval
+ # Add lower stringers from first spar until last spar
+ interval = (spar_x_l[-1] - spar_x_l[0]) / (stringer_l_2 + 1)
+ x = interval + spar_x_l[0]
+ for _ in range(0, stringer_l_2):
+ index = bi.bisect_left(airfoil_x_l, x)
+ self.x_l.append(airfoil_x_l[index])
+ self.z_l.append(airfoil_z_l[index])
+ x += interval
+ super().pack_info()
+ return None
+
+ def add_area(self, area):
+ self.area = area
+ return None
+
+ def add_mass(self, mass):
+ self.mass = len(self.x_u) * mass + len(self.x_l) * mass
+ return None
+
+ def print_info(self, round):
+ super().print_info(round)
+ print('Stringer Area:\n', np.around(self.area, round))
+ return None
+
+
+def plot(airfoil, spar, stringer):
+ """This function plots the elements passed as arguments."""
+
+ print('Plotting airfoil.')
+ # Plot chord
+ x_chord = [0, airfoil.chord]
+ y_chord = [0, 0]
+ plt.plot(x_chord, y_chord, linewidth='1')
+ # Plot mean camber line
+ plt.plot(airfoil.x_c,
+ airfoil.y_c,
+ '-.',
+ color='r',
+ linewidth='2')
+ # label='mean camber line')
+ # Plot upper surface
+ plt.plot(airfoil.x_u, airfoil.z_u, '', color='b', linewidth='1')
+ # Plot lower surface
+ plt.plot(airfoil.x_l, airfoil.z_l, '', color='b', linewidth='1')
+
+ # Plot spars
+ try:
+ for _ in range(0, len(spar.x_u)):
+ x = (spar.x_u[_], spar.x_l[_])
+ y = (spar.z_u[_], spar.z_l[_])
+ plt.plot(x, y, '.-', color='b')
+ # plt.legend()
+ except:
+ print('Did not plot spars. Were they added?')
+
+ # Plot stringers
+ try:
+ # Upper stringers
+ for _ in range(0, len(stringer.x_u)):
+ x = stringer.x_u[_]
+ y = stringer.z_u[_]
+ plt.plot(x, y, '.', color='y')
+ # Lower stringers
+ for _ in range(0, len(stringer.x_l)):
+ x = stringer.x_l[_]
+ y = stringer.z_l[_]
+ plt.plot(x, y, '.', color='y')
+ except:
+ print('Unable to plot stringers. Were they created?')
+
+ # Graph formatting
+ plt.gca().set_aspect('equal', adjustable='box')
+ plt.xlabel('X axis')
+ plt.ylabel('Z axis')
+ plt.grid(axis='both', linestyle=':', linewidth=1)
+ plt.show()
+ return None
+
+
+def main():
+ return None
+
+
+if __name__ == '__main__':
+ main()
diff --git a/evaluator.py b/evaluator.py
index 6a87b7e..69a589a 100644
--- a/evaluator.py
+++ b/evaluator.py
@@ -13,4 +13,22 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
-import creator
+# F_z =
+
+
+def get_centroid(airfoil):
+ area = airfoil.stringer.area
+ numerator = float()
+ for _ in airfoil.stringer.x_u:
+ numerator += _ * area
+ for _ in airfoil.stringer.x_l:
+ numerator += _ * area
+ denominator
+ # z_c =
+
+
+def get_total_mass(self, *component):
+ total_mass = float()
+ for _ in component:
+ total_mass += _.mass
+ return total_mass
diff --git a/main.py b/main.py
index 5d2e90a..ce69f6b 100644
--- a/main.py
+++ b/main.py
@@ -15,7 +15,7 @@
import creator # Create geometry
import evaluator # Evaluate geometry
-import generator # Iteratevely evaluate instances of geometry
+import generator # Iteratevely evaluate instances of geometry and optimize
import random
import time
@@ -24,43 +24,69 @@ start_time = time.time()
CHORD_LENGTH = 100
SEMI_SPAN = 200
+# m=Mass
+AIRFOIL_MASS = 100 # lbs
+SPAR_MASS = 10 # lbs
+STRINGER_MASS = 5 # lbs
+
+# Area
+STRINGER_AREA = 0.1 # sqin
+
+# population information
POP_SIZE = 1
SAVE_PATH = 'C:/Users/blend/github/UCLA_MAE_154B/save'
def main():
+ '''
+ Create an airfoil;
+ Evaluate an airfoil;
+ Generate a population of airfoils & optimize.
+ '''
+
# Create coordinate system specific to our airfoil dimensions.
+ # TODO: imperial + metric unit setting
creator.Coordinates(CHORD_LENGTH, SEMI_SPAN)
# Interate through all wings in population.
for _ in range(1, POP_SIZE + 1):
+
# Create airfoil instance
af = creator.Airfoil()
- # Define NACA airfoil coordinates
+ # Define NACA airfoil coordinates and mass
af.add_naca(2412)
- af.print_coord(2)
+ af.add_mass(AIRFOIL_MASS)
+ af.print_info(2)
# Create spar instance
af.spar = creator.Spar()
- # Define the spar coordinates, stored in single spar object
- af.spar.add(af.coord, 0.15)
- af.spar.add(af.coord, 0.55)
- af.spar.print_coord(2)
+ # Define the spar coordinates and mass, stored in single spar object
+ af.spar.add_coord(af.coord, 0.15)
+ af.spar.add_coord(af.coord, 0.55)
+ af.spar.add_mass(SPAR_MASS)
+ af.spar.print_info(2)
# Create stringer instance
af.stringer = creator.Stringer()
- # Define the stringer coordinates from their amount
- af.stringer.add(af.coord, af.spar.coord, 4, 7, 5, 6)
- # Print coordinates of af.stringer to terminal
- af.stringer.print_coord(2)
+ # Compute the stringer coordinates from their quantity in each zone
+ af.stringer.add_coord(af.coord, af.spar.coord, 4, 7, 5, 6)
+ af.stringer.add_area(STRINGER_AREA)
+ af.stringer.add_mass(STRINGER_MASS)
+ af.stringer.print_info(2)
# Plot components with matplotlib
creator.plot(af, af.spar, af.stringer)
- # Save component coordinates
- af.save_coord(SAVE_PATH, _)
- af.spar.save_coord(SAVE_PATH, _)
- af.stringer.save_coord(SAVE_PATH, _)
+ # Save component info
+ af.save_info(SAVE_PATH, _)
+ af.spar.save_info(SAVE_PATH, _)
+ af.stringer.save_info(SAVE_PATH, _)
+
+ # Evaluate previously created airfoil(s).
+ total_mass = evaluator.get_total_mass(af, af.spar, af.stringer)
+
+ # Iteratively evaluate airfoils by defining genetic generations.
+ # pass
# Print final execution time
print("--- %s seconds ---" % (time.time() - start_time))
Copyright 2019--2024 Marius PETER