home page
| forums | about |
projects | partners | contact
Welcome to Echovoice
Multithreaded, Object-Oriented Aircraft Design Project (.NET)
Michael Olsen and Teddy Garland



Multithreaded, Object-Oriented Aircraft Design Project (.NET)

Multithreaded, Object-Oriented Aircraft Design Project (.NET)

About the Project

The sizing and engine code has been written in C# for the following reasons:

Object Oriented, allows for breaking code out into objects and encapsulating data:

   1:  using(Plane P1 = new Plane(WEIGHT, WING_LOADING, ASPECT_RATIO, FUEL)) {
   2:       using(Simulation S1 = new Simulation(P1)) {
   4:       }
   5:  }

From the book entitled Aerospace Software Engineering –"… systems developed using object-oriented techniques are more likely to be stable and respect changes in functional requirements and their components are more likely to be reusable."

Multithreaded, allows the code to generate and simulate multiple planes simultaneously.

The completed code can build and fully simulate 2,000 planes in 6.81 seconds on 24 threads.

The program creates the geometry and simulates the mission. The sizing code is controlled by two for loops, one controlling aspect ratio and one controlling the wing loading. A gross weight estimate is also provided. The loop converges when the gross weight estimate is within 0.01% of the actual gross weight found at the end of the mission. The major upgrades to the sizing code include the engine model, and a more accurate engine re-sizing loop, noise calculations, Brent’s method for convergence, and the use of object oriented programming.

Any questions can be directed to: mike.plane2@echovoice.com.

Up the Ride - Logo

The input values of aspect ratio, wing loading, and gross weight were found based on comparison with current transport aircraft and data that was accessible. Initially, the gross weight was estimated to be 400,000 [lbs], this input would run the combination of wing loading and aspect ratio. After the first combination converged, in order to save compute time, the initial gross weight estimate would be that of the last converged aircraft. This allowed the program to quickly converge planes that had similar sized wing inputs. Wing loading was iterated from 120-200 [lb/ft2]. Typically, large aircraft will have a wing loading between 135 and 155 [lb/ft2]. These numbers are based on the Boeing 747-400 and Airbus A380. For sizing, it was prudent to iterate through all conditions to generate curves that show minimum values. At both ends of the wing loading spectrum aircraft begin to fail the mission due to engine sizes becoming too large. With low wing loadings, and large wings, the engines cannot overcome the climb and cruise drag without becoming exceedingly large. On the other end, the wings are too small, and the engines must be large to facilitate takeoff. The aspect ratios investigated were chosen based on current aircraft and the data available for sweep corrected Oswald Efficiency. It was desired to have higher aspect ratios to reduce the amount of induced drag, and thus an extra curve was extrapolated from the sweep correction charts for aspect ratio of 14.


Range of Values




120-200 [lb/ft2]

GW (initial)

400,000 [lb]

The geometry is created in the following order: fuselage, wings, winglet, horizontal tail, vertical tail, and then the engines. Using the seat map, the fuselage is created. The seat map was based on the Boeing 747, employing a two aisle system in the coach seating area. Next, the wings are built using the input from the for loops and the gross weight estimate. With the tip chord and the semi-span, the winglets can then be built. The height of the winglet (span) is added to the wing's span and the planform area is added to the wing's planform area. This effectively increases the aspect ratio. With the aerodynamic center, planform area of the wings and the mean aerodynamic chord, the horizontal tail can be built. In a similar fashion, the vertical tail uses the aerodynamic center, planform area of the wings and the mean aerodynamic chord. The tail volume coefficients, aspect ratio, and taper ratios were matched to a T-Tail design as defined by Raymer.

Multithreaded, Object-Oriented Aircraft Design Project (.NET)

There are many subfunctions required to size the engine, the balanced field length, high lift devices, and performance requirements.  The engine is first sized for takeoff at an altitude of 5,000 feet and balanced field length of 7,000 feet. To find the maximum lift coefficient, high lift devices are calculated. The selected high lift devices were the slotted flaps and the kruger flaps. These were chosen because they offer the largest increase in lift coefficient. By the definitions of these surfaces in the Raymer book, they are the only ones that do not have a factor of the flap chord over the wing chord. Since the high lift devices only encompass 25% of the wing area each, their effect would be only 1/4 of the stated value. This value is added to the CL of the airfoil’s clean configuration. To calculate the lift coefficient gained by the angle of attack, the losses due to 3D effects must be calculated. To do so, the lift curve slope is found in two dimensions, and then reduced based on aspect ratio and sweep in an incompressible airflow regime. This value is multiplied by the sum of the zero lift and geometric angle of attack. When added to the lift coefficient from the high lift devices, the takeoff CL has been found. Using the takeoff parameter equation, the amount of thrust required for takeoff can be found.

In most cases, the thrust required at takeoff will be the largest amount of thrust required for the mission. This is not always the case, however, and it is prudent to ensure that the engine can produce enough thrust to complete the mission. To find the maximum amount of thrust required, four extra conditions were tested, known as the performance requirements. They are the engine-out climb, normal climb, cruise, and maximum power cruise. The full simulation is run for both the climbs, and the maximum thrust is stored. In the case of the cruise conditions, just the first iteration is required, as the thrust will decrease as the weight decreases throughout the mission.  The engine model allows for the engine resize loop to be more accurate. Rather than sea level rating each of the engines, which were based on parameters for a single high bypass turbofan engine, the diameter can found based on the thrust at any altitude. Each of the maximum thrusts is passed into the turbofan model with their mach number, throttle setting, and altitude. This will return a diameter required to complete each mission segment. If a diameter happens to be larger than that of the takeoff requirement, then it becomes the new engine size, and the performance requirements are re-run until convergence. The engine was considered converged when the error between the new and previous iteration’s engine was less than 0.00001%.

Once the engines have been sized, the aircraft is ready to begin the mission. There is a 10 minute warm up period, followed by a 1 minute takeoff, then the climb. Climb is calculated as the amount of time required to get to the 31,000 foot altitude cruise. To do so, the change in velocity with respect to the change in height is calculated at each iteration. Following a climb schedule which dictates the true airspeed, the change in height at each iteration was found. Next, the aircraft performs the cruise. The cruise takes the aircraft 8,100 nautical miles at a constant altitude of 31,000 feet at mach 0.82. Using the engine model, a dynamic throttle is used to match the amount of drag at each iteration. After the cruise, an alternate cruise of 250 nautical miles is performed to find an alternate airport. A 45 minute loiter is then performed. After landing, the aircraft has a 10 minute taxi to the gate at the final destination, over 8,100 nautical miles from the takeoff point.

Finally, the empty weight is calculated. This is done using the component weight equations for a transport aircraft in Raymer’s book. The passenger, luggage, and crew weights are added to the empty weight and fuel weight to find the actual weight of the mission. When this converges, the aircraft is considered to be feasible and added to a text file detailing the wing loading, aspect ratio, gross weight, fuel consumed, and takeoff thrust.

Brent’s Method was used in many places for convergence, including the engine diameter based on thrust, and the dynamic throttle during cruise. This method was selected over Newton’s and the bisection method because of its speed and accuracy. This is shown in table 2, where the same parameters were given to the three different methods. The test involved finding the required diameter to produce the given thrust input 90,000 [lbs], with bounds of 50 to 200 [in] of fan diameter. From the results, it is clear that Brent’s was the most practical choice for this project. Brent’s Method combines many root finding methods. It includes the bisection method, secant method, and inverse quadratic interpolation. This speeds up the convergence, which is a requirement, as there are nearly 1000 iterations required to complete cruise with the throttle being set each time according to the required thrust. Brent’s Method takes in an upper and lower bound, then uses the three methods above to hone in on the root. Using lagrangian interpolating polynomials, the method should always converge when the value is within the bounds that are defined.


Value [in]

Time [ms]














The use of object oriented programming has greatly increased the speed of the computer simulation. This has been instrumental in debugging, as more iterations can be run to identify problem areas. Using a multi-threaded program allows for multiple aircraft to be calculated at the same time, rather than simply doing one at a time. Another major advantage comes in the variable passing through different functions. Rather than having a separate value for each parameter, there can be an object called “Wing”, which includes the planform area, span, aspect ratio, et cetera. This drastically keeps everything organized, well named, and the amount of typing down.

Multithreaded, Object-Oriented Aircraft Design Project (.NET)

Sample code: Create_Geometry.cs

   1:  using System;
   2:  using System.Collections.Generic;
   3:  using System.Linq;
   4:  using System.Text;
   5:  using Jet_Fuel;
   6:  using Engine_PurePower_PW1000G;
   7:  using RootFinder;
   8:  using Standard_Atmosphere;
   9:  using Flight_Characteristics;
  11:  namespace Aircraft_Geometry
  12:  {
  13:      public class Create_Geometry : IDisposable
  14:      {
  15:          // INTERMEDIATE
  16:          private double v_stall;
  17:          private double T1;
  18:          public double[] T0;
  19:          public double[] DIA;
  20:          private double DMAXo;       // Old Max Diameter
  21:          private double DMAXn;       // New Max Diameter
  22:          public double CLTO;
  25:          // OUTPUTS
  26:          public Fuselage f;
  27:          public Wing a;
  28:          public HorizontalTail b;
  29:          public VerticalTail c;
  30:          public Takeoff_Engine_Size e;   // Calculates Takeoff Requirements
  31:          public Performance p;           // Calculates thrust required to operate at 3 conditions
  32:          public Performance2 p2;         // Calculates diameter required to operate at 3 conditions
  33:          public double d;
  35:          public Create_Geometry(double GW, double WL, double AR, double alpha, Fuel fuel, double t_increase)
  36:          {
  37:              using (atmospheric_cal A = new atmospheric_cal(0))
  38:              {
  39:                  using (Mach M = new Mach(0, A))
  40:                  {
  41:                      using (TAS tas = new TAS(0, A))
  42:                      {
  43:                          // Generate Geometry
  44:                          f = new Fuselage();
  45:                          a = new Wing(GW, WL, AR);
  46:                          b = new HorizontalTail(a.get_S(), a.get_MAC(), f.fuse_l);
  47:                          c = new VerticalTail(a.get_S(), a.get_b(), a.get_MAC(), f.fuse_l);
  50:                          e = new Takeoff_Engine_Size(GW, a.get_S(), a.get_b(), a.get_sweep(), a.get_cr(), a.get_ct(), a.get_AR(), A, alpha, fuel, tas, t_increase);
  52:                          T1 = e.T1;
  53:                          v_stall = e.v_stall;
  54:                          CLTO = e.get_CLTO();
  55:                          d = e.d;
  56:                          p2 = new Performance2(GW, v_stall, A, M, tas, e.d, e.l, a, f, b, c, fuel);
  57:                          p = new Performance(GW, v_stall, A, M, e.d, e.l, a, f, b, c);
  59:                          //Pre-Allocate and Set Engine Diameters [in]
  60:                          DIA = new double[5];
  61:                          DIA[0] = d;                 // Takeoff
  62:                          DIA[1] = p2.get_d2();       // Engine-Out    
  63:                          DIA[2] = p2.get_d3();       // Normal Cruise
  64:                          DIA[3] = p2.get_d4();       // Max Power Cruise
  65:                          DIA[4] = p2.get_d5();       // Normal Climb
  67:                          // Validate Thrust Requirments - Re-size Engines
  68:                          if ((DIA[1] > DIA[0]) || (DIA[2] > DIA[0]) || (DIA[3] > DIA[0]) || (DIA[4] > DIA[0]))
  69:                          {
  70:                              DMAXo = DIA.Max();          // Initial Max Diameter
  71:                              p2.calcPerformance2(GW, v_stall, A, M, tas, DMAXo, e.l, a, f, b, c, fuel);
  72:                              DIA[1] = p2.get_d2();       // Engine-Out    
  73:                              DIA[2] = p2.get_d3();       // Normal Cruise
  74:                              DIA[3] = p2.get_d4();       // Max Power Cruise
  75:                              DIA[4] = p2.get_d5();       // Normal Climb
  76:                              DMAXn = DIA.Max();          // New Max Diameter
  78:                              // Check For New Max Diameter
  79:                              if (DMAXn > DMAXo)
  80:                              {
  81:                                  // Converge on Diameter Required for Mission
  82:                                  while (Math.Abs(DMAXn - DMAXo) / DMAXn > 0.000001)
  83:                                  {
  84:                                      DMAXo = DMAXn;              // Reset Old Max Diameter
  85:                                      p2.calcPerformance2(GW, v_stall, A, M, tas, DMAXo, e.l, a, f, b, c, fuel);
  86:                                      DIA[1] = p2.get_d2();       // Engine-Out    
  87:                                      DIA[2] = p2.get_d3();       // Normal Cruise
  88:                                      DIA[3] = p2.get_d4();       // Max Power Cruise
  89:                                      DIA[4] = p2.get_d5();       // Normal Climb
  90:                                      DMAXn = DIA.Max();          // New Max Diameter
  91:                                      Console.WriteLine();
  92:                                  }
  93:                              }
  94:                              d = DMAXn+0.5;                  // Set Engine Diameter to Max
  95:                          }
  97:                          d = DIA.Max()+0.5;                  // Set Engine Diameter to Max
  99:                          // Output Thrusts
 100:                          T0 = new double[4];
 101:                          T0[0] = T1;
 102:                          T0[1] = p2.get_T2();       // Engine-Out    
 103:                          T0[2] = p2.get_T3();       // Normal Cruise
 104:                          T0[3] = p2.get_T4();       // Max Power Cruise
 106:                      }
 107:                  }
 108:              }
 109:          }
 110:          public void Dispose() { }
 111:      }
 112:  }

The final project is written in 100% C#. It consists of 46 dll files. The entire solution is 23,147 lines of code, this does not include the GUI interface.

Multithreaded, Object-Oriented Aircraft Design Project (.NET)

Birkler, J. L. "Development and Production Cost Estimating Relationships for Aircraft Turbine Engines."The United States Airforce(1982). Print.

"The GE90 -An Introduction." Print.

The Jet Engine. London: Rolls-Royce, 2005. Print.


"Noise."Aircraft Aerodynamics and Design Group. Stanford University. Web. 19 Sept. 2011. <http://adg.stanford.edu/aa241/noise/noise.html>.

"PurePower™ PW1000G –Technology Features." (2011). Print.

PurePower® PW1000G Engine. Pratt & Whitney. Web. 19 Sept. 2011. <http://www.purepowerengine.com/>.

"PW1000G."MTUEngines. MTU. Web. Sescu, Adrian. "Towards Computational Aeroacoustics Prediction of Realistic Turbofan Broadband Noise Using Synthetic Turbulence Modeling." Print.

Svoboda, Charlie. "Turbofan Engine Database as a Preliminary Design Tool."Aircraft Design(2000). Web.

"US Engine Makers Gear up for 2025 and beyond."Flightglobal.com. Web. 19 Sept. 2011. <http://www.flightglobal.com/news/articles/us-engine-makers-gear-up-for-2025-and-beyond-354207/>.

"The Leading Edge", General Electric Aircraft Engines (GEAE), Spring 1993.

World Wide Web (WWW) Site -http://www.ge.com/geae/ge90.

H.Cohen, G.F.C.Rogers & H.I.HSaravanamuttoo, "Gas Turbine Theory",Longman, USA, Chap. 3., 3 ed., 1993.

J.D.Mattingly, W.H.Heiser& D.H.Daley, "Aircraft Engine Design", AIAAEducation Series, USA, Chap. 4-5, 1987.

"Energy Efficient Engine", NASA-CR-159859, June 1980.

D.Eckardt, "Future Engine Design Trade Offs", X ISOABE, Sept. 1991.

"Jane's All the World's Aircraft", UK, 1991-92.

Copyright © 2012 All Rights Reserved.
Echovoice® and Gamersvoice® are either registered trademarks or trademarks of Echovoice LLC in the United States and/or other countries.
The names of actual companies and products mentioned herein may be the trademarks of their respective owners.
Powered by Echovoice Technology

Home About Forums Projects Partners Contact Home