From 8b6f11119790c8c930734894a37d2a4aaa42462d Mon Sep 17 00:00:00 2001 From: blendoit Date: Fri, 1 Nov 2019 18:12:34 -0700 Subject: Start work on optimized multiprocessing random a/c gen. & eval. --- aircraftstudio/evaluator/__init__.py | 1 + aircraftstudio/evaluator/dP.py | 18 ++++ aircraftstudio/evaluator/drag.py | 18 ++++ aircraftstudio/evaluator/evaluator.py | 195 ++++++++++++++++++++++++++++++++++ aircraftstudio/evaluator/inertia.py | 66 ++++++++++++ aircraftstudio/evaluator/lift.py | 30 ++++++ aircraftstudio/evaluator/mass.py | 8 ++ 7 files changed, 336 insertions(+) create mode 100644 aircraftstudio/evaluator/__init__.py create mode 100644 aircraftstudio/evaluator/dP.py create mode 100644 aircraftstudio/evaluator/drag.py create mode 100644 aircraftstudio/evaluator/evaluator.py create mode 100644 aircraftstudio/evaluator/inertia.py create mode 100644 aircraftstudio/evaluator/lift.py create mode 100644 aircraftstudio/evaluator/mass.py (limited to 'aircraftstudio/evaluator') diff --git a/aircraftstudio/evaluator/__init__.py b/aircraftstudio/evaluator/__init__.py new file mode 100644 index 0000000..a58168b --- /dev/null +++ b/aircraftstudio/evaluator/__init__.py @@ -0,0 +1 @@ +from .evaluator import * diff --git a/aircraftstudio/evaluator/dP.py b/aircraftstudio/evaluator/dP.py new file mode 100644 index 0000000..b6aaa3b --- /dev/null +++ b/aircraftstudio/evaluator/dP.py @@ -0,0 +1,18 @@ +def get_dx(self, component): + return [x - self.centroid[0] for x in component.x_start] + + +def get_dz(self, component): + return [x - self.centroid[1] for x in component.x_start] + + +def get_dP(self, xDist, zDist, V_x, V_z, area): + I_x = self.I_['x'] + I_z = self.I_['z'] + I_xz = self.I_['xz'] + denom = float(I_x * I_z - I_xz**2) + z = float() + for _ in range(len(xDist)): + z += float(-area * xDist[_] * (I_x * V_x - I_xz * V_z) / denom - + area * zDist[_] * (I_z * V_z - I_xz * V_x) / denom) + return z diff --git a/aircraftstudio/evaluator/drag.py b/aircraftstudio/evaluator/drag.py new file mode 100644 index 0000000..73a26fc --- /dev/null +++ b/aircraftstudio/evaluator/drag.py @@ -0,0 +1,18 @@ +import random + +def get_drag(aircraft, drag): + # Transform semi-span integer into list + semi_span = [x for x in range(0, aircraft.wing.semi_span)] + + # Drag increases after 80% of the semi_span + cutoff = round(0.8 * aircraft.wing.span) + + # Drag increases by 25% after 80% of the semi_span + F_x = [drag for x in semi_span[0:cutoff]] + F_x.extend([1.25 * drag for x in semi_span[cutoff:]]) + return F_x + + +def get_drag_total(aircraft): + """Get total drag force acting on the aircraft.""" + return random.random() * 100 diff --git a/aircraftstudio/evaluator/evaluator.py b/aircraftstudio/evaluator/evaluator.py new file mode 100644 index 0000000..18bb692 --- /dev/null +++ b/aircraftstudio/evaluator/evaluator.py @@ -0,0 +1,195 @@ +""" +The evaluator.py module contains functions +that return calculated data for an aircraft. +Plotting aircraft components is also possible. +""" + +import os.path +import concurrent.futures +import matplotlib.pyplot as plt + +from . import drag, inertia, lift, mass + + +def analyze(aircraft): + """Analyze a single aircraft.""" + results = { + 'Lift': lift.get_lift_total(aircraft), + 'Drag': drag.get_drag_total(aircraft), + 'Mass': mass.get_mass_total(aircraft), + 'Centroid': inertia.get_centroid(aircraft) + } + aircraft.results = results + return aircraft.name, results + + +def analyze_all(population): + """Analyze all aircraft in a given population.""" + # for aircraft in population.aircrafts: + # print(analyze(aircraft)) + with concurrent.futures.ProcessPoolExecutor() as executor: + results = executor.map(analyze, population.aircrafts) + for result in results: + print(result) + return None + + # def analysis(self, V_x, V_z): + # """Perform all analysis calculations and store in class instance.""" + + # self.drag = self.get_drag(10) + # self.lift_rectangular = self.get_lift_rectangular(13.7) + # self.lift_elliptical = self.get_lift_elliptical(15) + # self.lift_total = self.get_lift_total() + # self.mass_dist = self.get_mass_distribution(self.mass_total) + # self.centroid = self.get_centroid() + # self.I_['x'] = self.get_inertia_terms()[0] + # self.I_['z'] = self.get_inertia_terms()[1] + # self.I_['xz'] = self.get_inertia_terms()[2] + # spar_dx = self.get_dx(self.spar) + # spar_dz = self.get_dz(self.spar) + # self.spar.dP_x = self.get_dP(spar_dx, spar_dz, V_x, 0, + # self.spar.cap_area) + # self.spar.dP_z = self.get_dP(spar_dx, spar_dz, 0, V_z, + # self.spar.cap_area) + # print("yayyyyy") + # return None + + # print(f"Analysis results for {aircraft.name}:\n", results) + # self.results = self.get_lift_total(aircraft) + + # self.drag = self.get_drag(10) + # self.lift_rectangular = self.get_lift_rectangular(13.7) + # self.lift_elliptical = self.get_lift_elliptical(15) + # self.lift_total = self.get_lift_total() + # self.mass_dist = self.get_mass_distribution(self.mass_total) + # self.centroid = self.get_centroid() + # self.I_['x'] = self.get_inertia_terms()[0] + # self.I_['z'] = self.get_inertia_terms()[1] + # self.I_['xz'] = self.get_inertia_terms()[2] + # spar_dx = self.get_dx(self.spar) + # spar_dz = self.get_dz(self.spar) + # self.spar.dP_x = self.get_dP(spar_dx, spar_dz, V_x, 0, + # self.spar.cap_area) + # self.spar.dP_z = self.get_dP(spar_dx, spar_dz, 0, V_z, + # self.spar.cap_area) + # return None + + def tree_print(self, population): + """Print the list of subcomponents.""" + name = f" TREE FOR {[i.name for i in population.aircraft]} IN {self.name} " + num_of_dashes = len(name) + print(num_of_dashes * '-') + print(name) + for aircraft in population: + print(".") + print(f"`-- {aircraft}") + print(f" |--{aircraft.wing}") + print(f" | |-- {aircraft.wing.stringers}") + for spar in aircraft.wing.spars[:-1]: + print(f" | |-- {spar}") + print(f" | `-- {aircraft.wing.spars[-1]}") + print(f" |-- {aircraft.fuselage}") + print(f" `-- {aircraft.propulsion}") + print(num_of_dashes * '-') + return None + + def tree_save(self, + population, + save_path='/home/blendux/Projects/Aircraft_Studio/save'): + """Save the evaluator's tree to a file.""" + for aircraft in population.aircraft: + file_name = f"{aircraft.name}_tree.txt" + full_path = os.path.join(save_path, file_name) + with open(full_path, 'w') as f: + try: + f.write(".\n") + f.write(f"`-- {aircraft}\n") + f.write(f" |--{aircraft.wing}\n") + for spar in aircraft.wing.spars[:-1]: + f.write(f" | |-- {spar}\n") + f.write(f" | `-- {aircraft.wing.spars[-1]}\n") + f.write(f" |-- {aircraft.fuselage}\n") + f.write(f" `-- {aircraft.propulsion}\n") + logging.debug(f'Successfully wrote to file {full_path}') + + except IOError: + print( + f'Unable to write {file_name} to specified directory.', + 'Was the full path passed to the function?') + return None + + +def plot_geom(evaluator): + """This function plots analysis results over the airfoil's geometry.""" + # Plot chord + x_chord = [0, evaluator.chord] + y_chord = [0, 0] + plt.plot(x_chord, y_chord, linewidth='1') + # Plot quarter chord + plt.plot(evaluator.chord / 4, + 0, + '.', + color='g', + markersize=24, + label='Quarter-chord') + # Plot airfoil surfaces + x = [0.98 * x for x in evaluator.airfoil.x] + y = [0.98 * z for z in evaluator.airfoil.z] + plt.fill(x, y, color='w', linewidth='1', fill=False) + x = [1.02 * x for x in evaluator.airfoil.x] + y = [1.02 * z for z in evaluator.airfoil.z] + plt.fill(x, y, color='b', linewidth='1', fill=False) + + # Plot spars + try: + for _ in range(len(evaluator.spar.x)): + x = (evaluator.spar.x[_]) + y = (evaluator.spar.z[_]) + plt.plot(x, y, '-', color='b') + except AttributeError: + print('No spars to plot.') + # Plot stringers + try: + for _ in range(0, len(evaluator.stringer.x)): + x = evaluator.stringer.x[_] + y = evaluator.stringer.z[_] + plt.plot(x, y, '.', color='y', markersize=12) + except AttributeError: + print('No stringers to plot.') + + # Plot centroid + x = evaluator.centroid[0] + y = evaluator.centroid[1] + plt.plot(x, y, '.', color='r', markersize=24, label='centroid') + + # Graph formatting + plt.xlabel('X axis') + plt.ylabel('Z axis') + + plot_bound = max(evaluator.airfoil.x) + plt.xlim(-0.10 * plot_bound, 1.10 * plot_bound) + plt.ylim(-(1.10 * plot_bound / 2), (1.10 * plot_bound / 2)) + plt.gca().set_aspect('equal', adjustable='box') + plt.gca().legend() + plt.grid(axis='both', linestyle=':', linewidth=1) + plt.show() + return None + + +def plot_lift(evaluator): + x = range(evaluator.semi_span) + y_1 = evaluator.lift_rectangular + y_2 = evaluator.lift_elliptical + y_3 = evaluator.lift_total + plt.plot(x, y_1, '.', color='b', markersize=4, label='Rectangular lift') + plt.plot(x, y_2, '.', color='g', markersize=4, label='Elliptical lift') + plt.plot(x, y_3, '.', color='r', markersize=4, label='Total lift') + + # Graph formatting + plt.xlabel('Semi-span location') + plt.ylabel('Lift') + + plt.gca().legend() + plt.grid(axis='both', linestyle=':', linewidth=1) + plt.show() + return None diff --git a/aircraftstudio/evaluator/inertia.py b/aircraftstudio/evaluator/inertia.py new file mode 100644 index 0000000..f047766 --- /dev/null +++ b/aircraftstudio/evaluator/inertia.py @@ -0,0 +1,66 @@ +def get_centroid(aircraft): + """Return the coordinates of the centroid.""" + # stringer_area = aircraft.wing.stringers.area + # cap_area = aircraft.wing.spars.cap_area + + # TODO: Fix this + # caps_x = [value for spar in aircraft.wing.spars.x for value in spar] + # caps_z = [value for spar in aircraft.wing.spars.z for value in spar] + # stringers_x = aircraft.wing.stringers.x + # stringers_z = aircraft.wing.stringers.z + + # denominator = float( + # len(caps_x) * cap_area + len(stringers_x) * stringer_area) + + # centroid_x = float( + # sum([x * cap_area + # for x in caps_x]) + sum([x * stringer_area for x in stringers_x])) + # centroid_x = centroid_x / denominator + + # centroid_z = float( + # sum([z * cap_area + # for z in caps_z]) + sum([z * stringer_area for z in stringers_z])) + # centroid_z = centroid_z / denominator + + # return (centroid_x, centroid_z) + return (200, 420) + + +def get_inertia_terms(self): + """Obtain all inertia terms.""" + stringer_area = self.stringer.area + cap_area = self.spar.cap_area + + # Adds upper and lower components' coordinates to list + x_stringers = self.stringer.x + z_stringers = self.stringer.z + x_spars = self.spar.x[:][0] + self.spar.x[:][1] + z_spars = self.spar.z[:][0] + self.spar.z[:][1] + stringer_count = range(len(x_stringers)) + spar_count = range(len(self.spar.x)) + + # I_x is the sum of the contributions of the spar caps and stringers + # TODO: replace list indices with dictionary value + I_x = sum( + [cap_area * (z_spars[i] - self.centroid[1])**2 for i in spar_count]) + I_x += sum([ + stringer_area * (z_stringers[i] - self.centroid[1])**2 + for i in stringer_count + ]) + + I_z = sum( + [cap_area * (x_spars[i] - self.centroid[0])**2 for i in spar_count]) + I_z += sum([ + stringer_area * (x_stringers[i] - self.centroid[0])**2 + for i in stringer_count + ]) + + I_xz = sum([ + cap_area * (x_spars[i] - self.centroid[0]) * + (z_spars[i] - self.centroid[1]) for i in spar_count + ]) + I_xz += sum([ + stringer_area * (x_stringers[i] - self.centroid[0]) * + (z_stringers[i] - self.centroid[1]) for i in stringer_count + ]) + return (I_x, I_z, I_xz) diff --git a/aircraftstudio/evaluator/lift.py b/aircraftstudio/evaluator/lift.py new file mode 100644 index 0000000..516d649 --- /dev/null +++ b/aircraftstudio/evaluator/lift.py @@ -0,0 +1,30 @@ +import numpy as np +from math import sqrt + + +def _get_lift_rectangular(aircraft, lift=50): + L_prime = np.array([ + lift / (aircraft.wing.semi_span * 2) + for _ in range(aircraft.wing.semi_span) + ]) + return L_prime + + +def _get_lift_elliptical(aircraft, L_0=3.2): + L_prime = np.array([ + 0.5 * L_0 / (aircraft.wing.semi_span * 2) * + sqrt(1 - (y / aircraft.wing.semi_span)**2) + for y in range(aircraft.wing.semi_span) + ]) + return L_prime + + +def get_lift_total(aircraft): + """Combination of rectangular and elliptical lift.""" + # F_z = self._get_lift_rectangular(aircraft) + self._get_lift_elliptical( + # aircraft) + # F_z = self._get_lift_rectangular( + # aircraft) + self._get_lift_elliptical(aircraft) / 2 + # F_z = [i + j for i, j in self._get_lift_rectangular] + # return F_z + return 400 diff --git a/aircraftstudio/evaluator/mass.py b/aircraftstudio/evaluator/mass.py new file mode 100644 index 0000000..7edb926 --- /dev/null +++ b/aircraftstudio/evaluator/mass.py @@ -0,0 +1,8 @@ +def get_mass_distribution(self, total_mass): + F_z = [total_mass / self.semi_span for x in range(0, self.semi_span)] + return F_z + + +def get_mass_total(aircraft): + """Get the total aircraft mass.""" + return 2000 -- cgit v1.2.3