User’s Guide to Running the Trajectory Code Using AAE450 ...
A.6.4 User’s Guide to Running the Trajectory Code
Compiled and Edited by Elizabeth Harkness
The trajectory code is a conglomeration of 27 MATLAB scripts and functions. The following document is meant to be a guide to anyone wishing to use the trajectory code. Each script or function in the trajectory code folder is briefly described here, with a listing of inputs needed and outputs generated. The first section, AAE450_Trajectory_run(_distribute).m, describes how to run the overall code, while the rest of the sections are more detailed descriptions of the separate components.
Index
|AAE450_Trajectory_run(_distribute).m |E. Harkness |page 2 |
|AAE450_Trajectory_Main.m |J. Kanehara |page 10 |
|AAE450_Trajectory_Get_Inputs.m |J. Kanehara |page 11 |
|AAE450_run_traj_Optimization_GB.m |D. Chua |page 12 |
|(AAE450_run_traj_Optimization_AC.m) | | |
|AAE450_Trajectory_D2MP.m |D. Chua |page 13 |
|AAE450_Trajectory_Calculations.m |J. Kanehara |page 14 |
|AAE450_Trajectory_ODE.m |J. Kanehara |page 15 |
|AAE450_Trajectory_ODE_AC_1st.m |J. Kanehara |page 17 |
|AAE450_Trajectory_ODE_AC_2nd.m |J. Kanehara |page 19 |
|AAE450_Trajectory_ODE_AC_linear.m |J. Kanehara |page 21 |
|AAE450_Trajectory_ODE_steer.m |J. Kanehara |page 23 |
|AAE450_Trajectory_ODE_coast.m |J. Kanehara |page 25 |
|AAE450_Wind_Model.m |K. Donahue |page 27 |
|atmosphere4.m |A. Guzik |page 28 |
|solve_cd.m |B. Ferris |page 29 |
|speedofsound.m |B. Ferris |page 30 |
|thrustprofile.m |B. Ferris |page 31 |
|AAE450_Trajectory_GSAC.m |A. Briden |page 32 |
|AAE450_Trajectory_GSAC_2STO.m |A. Briden |page 33 |
|AAE450_Trajectory_GSAC_Aircraft_2_3linear_sections.m |A. Briden |page 34 |
|AAE450_Trajectory_GSAC_Aircraft_3.m |A. Briden |page 36 |
|Delta_V.m |S. Breitengross |page 38 |
|AAE450_orbit_param.m |A. Guzik |page 39 |
|AAE450_Trajectory_outputs.m |J. Kanehara |page 40 |
|AAE450_Trajectory_Plots.m |J. Kanehara |page 41 |
|AAE450_Trajectory_Body2Inertial.m |J. Kanehara |page 42 |
|Code Flowchart: Run Once |K. Donahue |page 43 |
|Code Flowchart: Optimize |S. Breitengross |page 46 |
AAE450_Trajectory_run(_distribute).m
Written by Elizabeth Harkness
Revision 1.4 – 18 February 2008
Description:
The function AAE450_Trajectory_run.m interfaces between the output of the structures and propulsion codes and the input of the trajectory code while the function AAE450_Trajectory_run_distribute.m interfaces between the output of the structures and propulsion codes and the input of the trajectory code which uses AAE450_Trajectory_D2MP.m or AAE450_Trajectory_D2MP_ac.m to optimize steering angles (for ground/balloon or aircraft respectively). This document describes how AAE450_Trajectory_run.m and AAE450_Trajectory_run_distribute.m function, the required inputs and the expected outputs.
Input Section:
To get the inputs from the propulsion/structures code, the main_loop.m (MAT) code needs to be run with the following call line:
[ID,Trajectory_Input]= main_loop
Propulsion/Structures Inputs:
To make the input file for the AAE450_Trajectory_Main.m code, AAE450_Trajectory_run.m and AAE450_Trajectory_run_distribute.m need to be called with the call line:
AAE450_Trajectory_run(ID,Trajectory_Input)
or
AAE450_Trajectory_run_distribute(ID,Trajectory_Input)
All of the variables that are passed into the function from the propulsion/structures codes are described below:
|Variable Name |Description |
|ID |Run Identifier. This is the code for each case being run. |
| |E.g. ‘XX-XX-XX’ |
|type |If the case is running an air launch or ground launch. |
| |E.g. Ground: 1, Balloon: 2, Aircraft: 3. |
|N |Number of stages. E.g 1, 2, 3 |
|payload_mass |Mass of Payload [kg] E.g. 0.2, 1, 5 |
|m1 |Mass of the 1st Stage [kg] |
|m2 |Mass of the 2nd Stage [kg] |
|m3 |Mass of the 3rd Stage [kg] |
|T1 |Average Thrust of first stage. [N] |
|T2 |Average Thrust of second stage. [N] |
|T3 |Average Thrust of third stage. [N] |
|t_vertical |Time of vertical flight [s] |
|t_burn_1 |First stage burn time. [s] |
|t_burn_2 |Second stage burn time. [s] |
|t_burn_3 |Third stage burn time. [s] |
|m_dot_1 |Mass flow rate of 1st Stage. [kg/s] |
|m_dot_2 |Mass flow rate of 2nd Stage. [kg/s] |
|m_dot_3 |Mass flow rate of 3rd Stage. [kg/s] |
|diam_1 |Diameter of first stage. [m] |
|diam_2 |Diameter of second stage. [m] |
|diam_3 |Diameter of third stage. [m] |
|diam_4 |Diameter of fourth (payload) stage. [m] |
|Pe_1 |Exit pressure of 1st stage engine. [Pa] |
|Pe_2 |Exit pressure of 2nd stage engine. [Pa] |
|Pe_3 |Exit pressure of 3rd stage engine. [Pa] |
|Ae_1 |Exit area of 1st stage engine. [m^2] |
|Ae_2 |Exit area of 2nd stage engine. [m^2] |
|Ae_3 |Exit area of 3rd stage engine. [m^2] |
User Inputs:
AAE450_Trajectory_run.m
For Ground and Balloon Launch
After the propulsion/structures data has been loaded, the function will then prompt the user to input the steering angles:
|Variable Name |Description |
|psi1_0 |Angle at the end of 1st stage vertical [deg] |
|psi1_1 |Starting angle for end of first stage variation [deg] |
|psi1_2 |Final angle for end of first stage variation [deg] |
|psi_increment |Number of increments between psi1_1 and psi1_2 |
|psi2 |Angle at the end of 2nd stage [deg] |
|psi3 |Angle at the end of 3rd stage [deg] |
Note: To run only one steering angle, make psi1_1 equal to psi1_2 and set psi_increment to one. E.g. psi1_1 = 10, psi1_2 = 10, psi_increment = 1.
For Aircraft Launch
After the propulsion/structures data has been loaded, the function will then prompt the user to input the steering angles:
|Variable Name |Description |
|angle_tclimb |Steering angle at the end of climb [deg] |
|tb2sec1_percent_tb2 |Percent of first steering law for stage two [s] |
|psi2 |Angle at the end of 2nd stage [deg] |
|psi3 |Angle at the end of 3rd stage [deg] |
AAE450_Trajectory_run_distribute.m
For All Launch Types
There are no user generated inputs for AAE450_Trajectory_run_distribute.m, the steering angles are all varied by the program AAE450_Trajectory_D2MP.m (or AAE450_Trajectory_D2MP_ac.m for an aircraft launch).
Internal Inputs:
The following inputs are defined internally in AAE450_Trajectory_run.m and AAE450_Trajectory_run_distribute.m. These values should not need altering by the casual user (if ever). They include all initial conditions (these are set to vary with the type of launch), as well as some placeholder variables (labeled 4) for the orbit propagation stage.
|Variable Name |Description |
|h_i |Initial altitude [m] |
|psi1_0 |***Initial launch angle [deg] |
|r_dot_i_1 |Initial radial velocity [m/s] |
|theta_dot_i_1 |Initial tangential velocity [rad/s] |
|launch_lat |Launch latitude [deg] |
|launch_long |Launch longitude [deg] |
|phi_dot_i_1 |Initial phi velocity [rad/sec] |
|b_1 |Coefficient of angle at the end of 1st vertical stage. |
|R_Earth |Radius of the Earth [m] |
|t_vertical |Time of vertical flight to clear launch tower. [sec] |
*** Note: For AAE450_Trajectory_run_distribute.m only.
The values for these variables are shown below:
%% User non-variable inputs.
R_Earth = 6376*1000;
launch_lat = 28; %[deg]
launch_long = -80;
t_vertical = 10; %[sec]
(psi1_0 = 88;)
... ...
% Set initial conditions for different launches
if type == 1 % Ground
h_i = 0;
r_i_1=R_Earth+h_i; % [m]
r_dot_i_1 = 0; % [m/sec]
theta_i_1=launch_long*pi/180; % [rad]
theta_dot_i_1 = 0; % [rad]
phi_i_1=(90-launch_lat)*pi/180; % [rad]
phi_dot_i_1=0; % [rad/s]
b_1=tan(psi1_0*pi/180);
end
if type == 2 % Balloon
h_i = 30000;
r_i_1=R_Earth+h_i; % [m]
r_dot_i_1 = 0; % [m/sec]
theta_i_1=launch_long*pi/180; % [rad]
theta_dot_i_1 = 0; % [rad]
phi_i_1=(90-launch_lat)*pi/180; % [rad]
phi_dot_i_1=0; % [rad/s]
b_1=tan(psi1_0*pi/180);
end
if type == 3 % Airplane
h_i = 15000; % Launch Altitude (from MSL) [m] {Pegasus deployment Altitude}
r_i_1=R_Earth+h_i;
r_dot_i_1 = 0; % [m/sec]
theta_i_1=launch_long*pi/180;
theta_dot_i_1=59.72/r_i_1; % [rad/s]
phi_i_1=(90-launch_lat)*pi/180;
phi_dot_i_1=0;
b_1=tan(angle_tclimb*pi/180);
end
% Coasting Orbit Propagation Parameters
m4=0;
T4 = 0; % Zero thrust for coasting.
t_burn_4=3*60^2; % [s] for orbit trajectory
m_dot_4=0; % Mass flow rate of coasting Stage [kg/s]
Pe_4=0; % Exit pressure, 4th stage engine [Pa]
Ae_4=0; % Exit area, 4th stage engine [m^2]
diam_4=0;
... ...
if N==2
t_burn_3=0;
m_dot_3=0;
T3 = 0;
End
Output Section:
The function creates an input file called AAE450_Trajectory_Inputs.m this is the input file used by AAE450_Trajectory_Main.m. After writing the input file, the main trajectory code needs to be run to generate the solution. The call line is simply:
AAE450_Trajectory_Main
for AAE450_Trajectory_run.m and
AAE450_Trajectory_D2MP
for AAE450_Trajectory_run_distribute.m.
Or, for an aircraft launch,
AAE450_Trajectory_D2MP_ac
Note: Before running AAE450_Trajectory_Main.m, make sure that the script AAE450_Get_Inputs.m has the script AAE450_Trajectory_Inputs.m as the only uncommented line. Otherwise, AAE450_Trajectory_Main.m will not load the correct inputs.
Once AAE450_Trajectory_Main.m has been run, an output file will be written. This output file is a copy of what has been printed to the MATLAB Command Window and is named with the Case ID number that was assigned to it. (E.g. MG-CA-DS-DC)
AAE450_Trajectory_run.m Sample Output:
The output of AAE450_Trajectory_run(_distribute).m is the input file for the AAE450_Trajectory_Main.m.
File: AAE450_Trajectory_Inputs.m:
ID = 'SB-HA-DA-DA.txt';
type = 2.0000000000;
airplane = 0.0000000000;
N = 3.0000000000;
h_i = 30000.0000000000;
r_i_1 = 6406000.0000000000;
r_dot_i_1 = 0.0000000000;
theta_dot_i_1 = 0.0000000000;
payload_mass = 0.2000000000;
t_vertical = 10.0000000000;
t_burn_1 = 147.7675026979;
t_burn_2 = 160.8812170075;
t_burn_3 = 206.2408603065;
psi1_1 = psi1orig;
psi2 = psi2orig;
psi3 = psi3orig;
psi1_0 = 88.0000000000;
m1 = 437.8415091229;
m2 = 91.5734691245;
m3 = 31.2258015670;
T1 = 6606.1670069556;
T2 = 1392.5576461998;
T3 = 355.7926808351;
m_dot_1 = 2.0741303114;
m_dot_2 = 0.4325914350;
m_dot_3 = 0.1105253106;
diam_1 = 0.7731278821;
diam_2 = 0.3350953988;
diam_3 = 0.2309862864;
diam_4 = 0.0000000000;
Pe_1 = 2821.1669372331;
Pe_2 = 11453.6603989692;
Pe_3 = 11453.6603989692;
Ae_1 = 0.1054496676;
Ae_2 = 0.0064027858;
Ae_3 = 0.0016358851;
launch_lat = 28.0000000000;
launch_long = -80.0000000000;
theta_i_1 = -1.3962634016;
phi_i_1 = 1.0821041362;
phi_dot_i_1 = 0.0000000000;
b_1 = 28.6362532829;
phi_i_1 = 1.0821041362;
m4 = 8.4309664231;
T4 = 0.0000000000;
t_burn_4 = 32400.0000000000;
m_dot_4 = 0.0000000000;
Pe_4 = 0.0000000000;
Ae_4 = 0.0000000000;
m0_1 = 560.8407798144;
m0_2 = 122.9992706915;
m0_3 = 31.4258015670;
m0_4 = 8.6309664231;
Sample Output for Entire Trajectory Code:
The following is a sample output of the entire trajectory code (this is the output of the code AAE450_Trajectory_outputs.m). This is output to both the MATLAB command window as well as to a text file that has the same name as the case ID:
Currently running 24 deg case.
***************************************
Output from AAE450_Trajectory_outputs.m
***************************************
Case ID: LB_HA_DA_DA
Orbital Parameters
Period: 6038.7878 [s]
Semi-major axis: 7167.36 [km]
eccentricity: 0.0025
periapsis: 773.14 [km](from the surface of the Earth)
apoapsis: 809.57 [km](from the surface of the Earth)
Linear Tangent Steering Parameters:
a1 = -0.16117 b1 = 28.6363
a2 = -0.00502483 b2 = 1.32415
a3 = 2.86231e-019 b3 = -0.624869
Flight Path Angle = 0.1 [deg].
at t=0[s]:
Altitude: h=30000 [m] (Initial Condition)
Radial(Vertical) Speed: Vr=0 [m/s] (Initial Condition)
Payload Mass= 5.000 [kg]
GLOW= 6294.7686 [kg]
Thrust
1st stage: 75.073 [kN]
2nd stage: 15.257 [kN]
3rd stage: 0.692 [kN]
Max Acceleration
Max a @1st Stage= 28.5 [m/s^2]
Max a @1st Stage= 2.90 G
Max a @2nd Stage= 51.2 [m/s^2]
Max a @2nd Stage= 5.22 G
Max a @3rd Stage= 39.0 [m/s^2]
Max a @3rd Stage= 3.97 G
Max a @Coasting Stage= 3.8 [m/s^2]
Max a @Coasting Stage= 0.38 G
Burn Times
1st Stage: 175[s]
(first 10.00 [s] is vertical flight)
2nd Stage: 212.96[s]
3rd Stage: 178.40[s]
Times at the end of each stage
End of first stage: 174.00[s]
End of second stage: 386.00[s]
End of third stage: 564.00[s]
Constant Mass Flow Rates
1st Stage: 23.571[kg/s]
2nd Stage: 4.739[kg/s]
3rd Stage: 0.215[kg/s]
Constant Exit Pressures
1st Stage: 2.82[kPa]
2nd Stage: 11.45[kPa]
3rd Stage: 11.45[kPa]
Altitudes
at the end of the vertical part of flight: 30112.44[m]
at t= 0 [s] : 30.00[km]
at the end of the first stage: 131.57[km]
at the end of the second stage: 560.08[km]
at the end of the third stage: 801.62[km]
from AAE450_Delta_V.m
Delta_V_Thrust_1st= 3486 [m/s] (29.4 percent)
Delta_V_Thrust_2nd= 4775 [m/s] (40.3 percent)
Delta_V_Thrust_3rd= 3592 [m/s] (30.3 percent)
Delta_V_Thrust_Total (what we get)= 11853 [m/s]
Delta_V_Leo= 7727 [m/s]
Delta_V_Grav= 2034 [m/s]
DeltaV_drag= 4 [m/s]
Delta_V_Earth_assist= 411 [m/s]
Delta_V_Total (what we need)= 9354 [m/s]
Delta V required to circularize: 568 [m/s]
************************************************************
Note: it takes approximately 20[s] to produce all the plots.
Please wait until you get the three figures of 3-D plots.
There are six plots that are output:
Figure 1: Distance from the ground versus time
Figure 3: Radial speed versus time
Figure 5: Tangential speed versus time
Figure 6: Three views of the 3D orbit and trajectory
Figure 7: One view of the orbit (with wireframe Earth)
Figure 8: One view of the orbit (with solid sphere Earth)
AAE450_Trajectory_Main.m
Written by Junichi Kanehara
Revision 1.0 – 16 March 2008
Description:
AAE450_Trajectory_Main.m is the main script of the trajectory code. This code calls all the necessary scripts and functions in order to compute and output the numerical results and produce plots for one particular set of input.
Assumptions:
All necessary inputs are assumed to be given by the input file, AAE450_Trajectory_Inputs.m, which has either been created by AAE450_Trajectory_run.m or AAE450_Trajectory_run_distribute.m as described above.
Important Notes:
The log section of this main script addresses the modifications in every component of the entire trajectory code.
Input Section:
The call line of the script is:
AAE450_Trajectory_Main
Output Section:
There is no “output” in the way a function does since this is a script.
AAE450_Get_Inputs.m
Written by Junichi Kanehara
Revision 1.0 – 16 March 2008
Description:
This is a simple script that chooses which input file to call.
Important Notes:
In the early version of the codes, AAE450_Trajectory_default_inputs was usually called.
In the later version of the codes, AAE450_Trajectory_Inputs was usually called.
In the final version of the codes, the winners of each case such as LB_HA_DA_DA_v125_Inputs should be called.
Input Section:
The call line of the function is:
AAE450_Get_Inputs
Output Section:
All the necessary input variables should be obtained by this script, as it calls an input file.
AAE450_run_traj_Optimization_GB.m (AAE450_run_traj_Optimization_AC.m)
Written by Daniel Chua
Revision 1.0 – 10 March 2008
Description:
AAE450_run_traj_Optimization_GB.m runs AAE450_Trajectory_Main.m multiple times for each given steering angle. AAE450_run_traj_Optimization_AC.m runs AAE450_Trajectory_Main.m multiple times for each given aircraft input.
Input Section:
The input to AAE450_run_traj_Optimization_GB(AC).m is the input file generated by AAE450_Trajectory_run_distribute.m.
Output Section:
For each iteration of steering angle through AAE450_Trajectory_Main.m, AAE450_run_traj_Optimization_GB(AC).m outputs the results to the following files:
• outfile.txt : an output file holding the results of feasible iterations of AAE450_Trajectory_Main.m
• failfile.txt : an output file holding the results of infeasible iterations of AAE450_Trajectory_Main.m
• optcount.txt : an output file used to track the number of completed iterations
AAE450_Trajectory_D2MP.m
Written by Daniel Chua
Revision 1.0 – 10 March 2008
Description:
AAE450_Trajectory_D2MP.m runs AAE450_run_traj_Optimization_GB(AC).m multiple times, narrowing the range of steering angles input into AAE450_run_traj_Optimization_GB(AC).m with each iteration. The least eccentric output from AAE450_run_traj_Optimization_GB(AC).m is displayed and used to run AAE450_Trajectory_Main.m to show the results of using the steering angles that give the least eccentric trajectory. If the Distributed Computing Toolbox (DCT) is installed, the optimization process is distributed to as many processors as are available to MATLAB.
AAE450_Trajectory_Calculations.m
Written by Junichi Kanehara
Revision 1.0 – 16 March 2008
Description:
This is a script called by AAE450_Trajectory_Main.m that computes the time history of the position and the velocity in the spherical coordinating system and ΔV’s in each stage by calling ODE files (described below).
Input Section:
The call line of the function is:
AAE450_Trajectory_Calculations
Output Section:
The main output of this script is the time history of the position and the velocity in the spherical coordinating system. Please see the description of AAE450_Delta_V.m for ΔV’s.
|Variable Name |Description |
|r |The radial position from the center of the Earth [m] |
|r_dot |The radial velocity [m/s] |
|theta |One component of angular position [rad] |
|theta_dot |One component of angular velocity [rad/s] |
|phi |The other component of angular position [rad] |
|phi_dot |The other component of angular velocity [rad/s] |
| V |Speed of the rocket [m/s] |
AAE450_Trajectory_ODE.m
Written by Junichi Kanehara
Revision 1.0 – 17 March 2008
Description:
This is an ordinary differential equation solver; the state variables 1 through 6 are for the time history of the position and the velocity in the spherical coordinating system, and the state variables 7 and 8 are the ΔV’s due to the drag and the propulsion respectively.
The first line of this function is:
function xdot=AAE450_Trajectory_ODE(t,x,T_full,m0,m_dot,Pe,Ae,t_burn,diam)
Assumptions:
It is assumed that the rocket is launched vertically and is not steering.
Important Notes:
Since this is an ODE, we need the initial conditions, which are defined when the input file is written:
x_i_1v=[r_i_1 r_dot_i_1 theta_i_1 theta_dot_i_1 phi_i_1 phi_dot_i_1 0 0];
t_i_1v=[0:time_step:t_vertical];
Input Section:
The call line of the function is:
[t1_v,x1_v]=
ode45(@(t,x)AAE450_Trajectory_ODE(t,x,T1_temp,m0_1,m_dot_1,Pe_1,Ae_1, t_burn_1,diam_1),t_i_1v,x_i_1v,options);
All of the variables that are passed into the function are described below:
|Variable Name |Description |
|t |Time vector [s] |
|x |State Variables |
|T_full |Constant Thrust [N] |
| |Note: thrustprofile.m should be used inside the ODE. |
|m0 |Initial Mass of the rocket [kg] |
|m_dot |Constant mass flow rate [kg/s] |
|Pe |Exit Pressure [Pa] |
|Ae |Exit Area [[pic]] |
|t_burn |Burn time [s] |
|diam |Cross sectional diameter of the rocket [m] |
Output Section:
The following commands are used to convert from the state variables to the variables with physical meanings, which will be used in the calculations section of the main program:
r_1_v=x1_v(:,1);
r_dot_1_v=x1_v(:,2);
theta_1_v=x1_v(:,3);
theta_dot_1_v=x1_v(:,4);
phi_1_v=x1_v(:,5);
phi_dot_1_v=x1_v(:,6);
deltaV_1v_drag=(x1_v(:,7));
deltaV_1v_drag=deltaV_1v_drag(length(deltaV_1v_drag));
deltaV_1v_thrust=(x1_v(:,8));
deltaV_1v_thrust=deltaV_1v_thrust(length(deltaV_1v_thrust));
AAE450_Trajectory_ODE_AC_1st.m
Written by Junichi Kanehara
Revision 1.0 – 17 March 2008
Description:
This is an ordinary differential equation solver for the first stage of the aircraft launch; the state variables 1 through 6 are for the time history of the position and the velocity in the spherical coordinating system, and the state variables 7 through 9 are the ΔV’s due to the drag, the gravity loss and the propulsion respectively.
The first line of this function is:
function xdot=AAE450_Trajectory_ODE_AC_1st(t,x,T_full,m0,m_dot,a,Pe,Ae,t_burn,diam)
Assumptions:
We assume that the rocket is launched from an aircraft and is steering.
Important Notes:
Since this is an ODE, we need the initial conditions:
x_i_1s=[r_i_1 r_dot_1_s theta_i_1 theta_dot_i_1 phi_i_1 phi_dot_i_1 0 0 0];
t_i_1s=[0:time_step:t_burn1];
Input Section:
The call line of the function is:
[t1_s,x1]=ode45(@(t,x)AAE450_Trajectory_ODE_AC_1st(t,x,T1,m0_1_v,m_dot_1,a_1
Pe_1,Ae_1,t_burn_1,diam_1),t_i_1s,x_i_1s,options);
All of the variables that are passed into the function are described below:
|Variable Name |Description |
|t |Time vector [s] |
|x |State Variables |
|T_full |Constant Thrust [N] |
| |Note: thrustprofile.m should be used inside the ODE. |
|m0 |Initial Mass of the rocket [kg] |
|m_dot |Constant mass flow rate [kg/s] |
|Pe |Exit Pressure [Pa] |
|Ae |Exit Area [[pic]] |
|t_burn |Burn time [s] |
|diam |Cross sectional diameter of the rocket [m] |
|a |The Coefficient of the Steering Law |
Output Section:
The following commands are useful to convert from the state variables to the variables with physical meanings:
r_1=x1(:,1);
r_dot_1=x1(:,2);
theta_1=x1(:,3);
theta_dot_1=x1(:,4);
phi_1=x1(:,5);
phi_dot_1=x1(:,6);
deltaV_1s_drag=(x1(:,7));
deltaV_1s_drag=deltaV_1s_drag(length(deltaV_1s_drag));
deltaV_1s_gravity=(x1(:,8));
deltaV_1s_gravity=deltaV_1s_gravity(length(deltaV_1s_gravity));
deltaV_1s_thrust=(x1(:,9));
deltaV_1s_thrust=deltaV_1s_thrust(length(deltaV_1s_thrust));
AAE450_Trajectory_ODE_AC_2nd.m
Written by Junichi Kanehara
Revision 1.0 – 17 March 2008
Description:
This is an ordinary differential equation solver for the second stage of the aircraft launch; the state variables 1 through 6 are for the time history of the position and the velocity in the spherical coordinating system, and the state variables 7 through 9 are the ΔV’s due to the drag, the gravity loss and the propulsion respectively.
The first line of this function is:
function xdot=AAE450_Trajectory_ODE_AC_2nd(t,x,T_full,m0,m_dot,a2sec1,b2sec1,a2sec2,
b2sec2,a2sec3,b2sec3,Pe,Ae,t_burn,diam,tsec1,tsec2);
Assumptions:
We assume that the rocket is launched from an aircraft and is steering.
Important Notes:
Since this is an ODE, we need the initial conditions:
x_i_2=[r_i_2 r_dot_i_2 theta_i_2 theta_dot_i_2 phi_i_2 phi_dot_i_2 0 0 0];
t_i_2=[0:time_step:t_burn2];
Input Section:
The call line of the function is:
[t2,x2]=ode45(@(t,x)AAE450_Trajectory_ODE_AC_2nd(t,x,T2,m0_2,m_dot_2,a2_sec1,
b2_sec1,a2_sec2,b2_sec2,a2_sec3,b2_sec3,Pe_2,Ae_2,
t_burn_2,diam_2,tb2_sec1,tb2_sec2),t_i_2,x_i_2,options);
Some of the variables that are passed into the function are described below:
|Variable Name |Description |
|T |Time vector [s] |
|x |State Variables |
|T_full |Constant Thrust [N] |
| |Note: thrustprofile.m should be used inside the ODE. |
|m0 |Initial Mass of the rocket [kg] |
|m_dot |Constant mass flow rate [kg/s] |
|Pe |Exit Pressure [Pa] |
|Ae |Exit Area [[pic]] |
|t_burn |Burn time [s] |
|diam |Cross sectional diameter of the rocket [m] |
|a2_sec1 |a Coefficient of the Steering Law |
|tb2_sec1 |Time for the first segment [s] |
Output Section:
The following commands are useful to convert from the state variables to the variables with physical meanings:
r_2=x2(:,1);
r_dot_2=x2(:,2);
theta_2=x2(:,3);
theta_dot_2=x2(:,4);
phi_2=x2(:,5);
phi_dot_2=x2(:,6);
deltaV_2_drag=(x2(:,7));
deltaV_2_drag=deltaV_2_drag(length(deltaV_2_drag));
deltaV_2_gravity=(x2(:,8));
deltaV_2_gravity=deltaV_2_gravity(length(deltaV_2_gravity));
deltaV_2_thrust=(x2(:,9));
deltaV_2_thrust=deltaV_2_thrust(end);
AAE450_Trajectory_ODE_AC_linear.m
Written by Junichi Kanehara
Revision 1.0 – 17 March 2008
Description:
This is an ordinary differential equation solver for the third stage of the aircraft launch; the state variables 1 through 6 are for the time history of the position and the velocity in the spherical coordinating system, and the state variables 7 through 9 are the ΔV’s due to the drag, the gravity loss and the propulsion respectively.
The first line of this function is:
function xdot=AAE450_Trajectory_ODE_AC_linear(t,x,T_full,m0,m_dot,a,b,Pe,Ae,t_burn,diam)
Assumptions:
We assume the rocket is launched from an aircraft and is steering.
Important Notes:
Since this is an ODE, we need the initial conditions:
x_i_3=[r_i_3 r_dot_i_3 theta_i_3 theta_dot_i_3 phi_i_3 phi_dot_i_3 0 0 0];
t_i_3=[0:time_step:t_burn3];
Input Section:
The call line of the function is:
[t3,x3]=ode45(@(t,x) AAE450_Trajectory_ODE_AC_linear
(t,x,T3,m0_3,m_dot_3,a_3,b_3,Pe_3,Ae_3,t_burn_3,
diam_3),t_i_3,x_i_3,options);
All of the variables that are passed into the function are described below:
|Variable Name |Description |
|t |Time vector [s] |
|x |State Variables |
|T_full |Constant Thrust [N] |
| |Note: thrustprofile.m should be used inside the ODE. |
|m0 |Initial Mass of the rocket [kg] |
|m_dot |Constant mass flow rate [kg/s] |
|Pe |Exit Pressure [Pa] |
|Ae |Exit Area [[pic]] |
|t_burn |Burn time [s] |
|diam |Cross sectional diameter of the rocket [m] |
|a |a Coefficient of the Steering Law |
|b |a Coefficient of the Steering Law |
Output Section:
The following commands are useful to convert from the state variables to the variables with physical meanings:
r_3=x3(:,1);
r_dot_3=x3(:,2);
theta_3=x3(:,3);
theta_dot_3=x3(:,4);
phi_3=x3(:,5);
phi_dot_3=x3(:,6);
deltaV_3_drag=(x3(:,7));
deltaV_3_drag=deltaV_3_drag(length(deltaV_3_drag));
deltaV_3_gravity=(x3(:,8));
deltaV_3_gravity=deltaV_3_gravity(length(deltaV_3_gravity));
deltaV_3_thrust=(x3(:,9));
deltaV_3_thrust=deltaV_3_thrust(end);
AAE450_Trajectory_ODE_steer.m
Written by Junichi Kanehara
Revision 1.0 – 17 March 2008
Description:
This is an ordinary differential equation solver for the ground launch and the balloon launch; the state variables 1 through 6 are for the time history of the position and the velocity in the spherical coordinating system, and the state variables 7 through 9 are the delta V’s due to the drag, the gravity loss and the propulsion respectively.
The first line of this function is:
function xdot=AAE450_Trajectory_ODE_steer
(t,x,T_full,m0,m_dot,a,b,Pe,Ae,t_burn,diam)
Assumptions:
We assume the rocket is steering, following the linear tangent law.
Important Notes:
Since this is an ODE, we need the initial conditions:
x_i_2=[r_i_2 r_dot_i_2 theta_i_2 theta_dot_i_2 phi_i_2 phi_dot_i_2 0 0 0];
t_i_2=[0:time_step:t_burn_2];
Input Section:
The call line of the function is:
[t2,x2]=ode45(@(t,x) AAE450_Trajectory_ODE_steer(t,x,T2,m0_2,m_dot_2,a_2,b_2,
Pe_2,Ae_2,t_burn_2,diam_2),t_i_2,x_i_2,options);
All of the variables that are passed into the function are described below:
|Variable Name |Description |
|t |Time vector [s] |
|x |State Variables |
|T_full |Constant Thrust [N] |
| |Note: thrustprofile.m should be used inside the ODE. |
|m0 |Initial Mass of the rocket [kg] |
|m_dot |Constant mass flow rate [kg/s] |
|Pe |Exit Pressure [Pa] |
|Ae |Exit Area [[pic]] |
|t_burn |Burn time [s] |
|diam |Cross sectional diameter of the rocket [m] |
|a |a Coefficient of the Steering Law |
|b |a Coefficient of the Steering Law |
Output Section:
The following commands are useful to convert from the state variables to the variables with physical meanings:
r_2=x2(:,1);
r_dot_2=x2(:,2);
theta_2=x2(:,3);
theta_dot_2=x2(:,4);
phi_2=x2(:,5);
phi_dot_2=x2(:,6);
deltaV_2_drag=(x2(:,7));
deltaV_2_drag=deltaV_2_drag(length(deltaV_2_drag));
deltaV_2_gravity=(x2(:,8));
deltaV_2_gravity=deltaV_2_gravity(length(deltaV_2_gravity));
deltaV_2_thrust=(x2(:,9));
deltaV_2_thrust=deltaV_2_thrust(end);
AAE450_Trajectory_ODE_coast.m
Written by Junichi Kanehara
Revision 1.0 – 17 March 2008
Description:
This is an ordinary differential equation solver for the coasting stage in orbit; the state variables 1 through 6 are for the time history of the position and the velocity in the spherical coordinating system.
The first line of this function is:
function xdot=AAE450_Trajectory_ODE_coast(t,x,T,m0,m_dot,C_D,Pe,Ae,t_burn,diam)
Assumptions:
We assume that no thrust or drug is acting.
Important Notes:
Since this is an ODE, we need the initial conditions:
x_i_4=[r_i_4 r_dot_i_4 theta_i_4 theta_dot_i_4 phi_i_4 phi_dot_i_4 0];
t_i_4=[0:time_step:t_burn_4];
Input Section:
The call line of the function is:
[t4,x4]=ode45(@(t,x) AAE450_Trajectory_ODE_coast(t,x,T4,m0_4,m_dot_4,
C_D_orbit,Pe_4,Ae_4,t_burn_4,diam_4),t_i_4,x_i_4,options);
Some of the variables that are passed into the function are described below:
|Variable Name |Description |
|t |Time vector [s] |
|x |State Variables |
|T |Thrust = 0 [N] |
|t_burn |Length of Time to run this ODE [s] |
| |This should be longer than one period of the orbit. |
Output Section:
The following commands are useful to convert from the state variables to the variables with physical meanings:
r_4=x4(:,1);
r_dot_4=x4(:,2);
theta_4=x4(:,3);
theta_dot_4=x4(:,4);
phi_4=x4(:,5);
phi_dot_4=x4(:,6);
AAE450_Wind_Model.m
Written by Kyle Donahue
Revision 1.0 – 24 March 2008
Description:
AAE450_Wind_Model.m uses atmosphere4.m to help create a wind profile. The wind profile is made up of a constant wind profile and randomized wind gusting. It also creates the wind force which the wind velocity causes on the launch vehicle.
Assumptions:
One assumption is the constant wind can only go from 0o to 180o on the compass. The wind gusting angle can only be ±90o from the constant wind at the given altitude. Also the wind is only 2-D which means it will never go “up” or “down”.
Important Notes:
The log section of this script addresses the modifications in every component of the entire trajectory code.
Input Section:
The call line of the script is:
AAE450_Wind_Model
Output Section:
The output is only plots of the wind profile in the north/south direction, the wind profile in the east/west direction, the force of the wind in the north/south direction, and the force of the wind in the east/west direction. It also puts the wind force Fw variable in the workspace so it can be used in the equations of motion.
atmosphere4.m
Written by Allen Guzik
Revision 1.0 – 24 March 2008
Description:
This function calculates static conditions of Earth’s atmosphere based on a given altitude. This program was no written by the design team. However, it is commonly used and accepted as a source to obtain standard atmospheric conditions.
Assumptions:
Data is based off of the 1976 NASA standard atmosphere.
Input Section:
The call line of the function is:
[temp,press,rho,Hgeopvector]=atmosphere4(Hvector,GeometricFlag)
All of the variables that are passed into the function are described below:
|Variable Name |Description |
|Hvector |Vector of geopotential or geometric altitudes [ft] |
|GeometricFlag |Denote if the altitude is geopotential or geometric. |
Output Section:
Atmospheric conditions calculated are:
|Variable Name |Description |
|temp |Temperature [°R] |
|press |Pressure [lbf/ft2] |
|rho |Density [slug/ft3] |
|Hgeopvector |Vector of corresponding geopotential altitudes [ft]. |
solve_cd.m
Written by Brad Ferris
Revision 1.0 – 07 March 2008
Description:
This function was originally written by Jayme Zott from the Aerothermal group. The function was implemented into AAE450_Trajectory_Main.m by Brad Ferris. This function calculates a coefficient of drag value based on the current flight Mach number. This allows AAE450_Trajectory_Main.m to more accurately model drag throughout the launch vehicle’s flight.
Input Section:
The flight Mach number is input from the ODE functions.
Output Section:
The coefficient of drag corresponding to the input Mach number is output to the ODE functions.
speedofsound.m
Written by Brad Ferris
Revision 1.0 – 07 March 2008
Description:
This function calculates the current speed of sound.
Input Section:
The current flight temperature is input from atmosphere4.m and AAE450_Trajectory_Calculations.m.
Output Section:
The speed of sound corresponding to current flight conditions is output to the body of the code.
thrustprofile.m
Written by Brad Ferris
Revision 1.0 – 07 March 2008
Description:
The purpose of this function is to model the ramp up and ramp down times of a rocket engine. In its most current revision, the ramp up and ramp down times are one second.
Input Section:
The maximum nominal input, the total burn time, and current time are input into the function.
Output Section:
The thrust corresponding to the current flight time is output to the ODE functions. If the point of time is during the ramping period, the thrust returned will be less than maximum thrust.
AAE450_Trajectory_GSAC.m
Written by Amanda Briden
Revision 1.0 – 16 March 2008
Description:
This script determines the steering angle coefficients for a linear tangent steering law for each stage of a balloon or ground launch. It then saves the coefficients to a text file called ab.txt.
Assumptions:
The desired steering angles at the end of each stage and the burn times for each stage are already defined.
Important Notes:
This script is only called in AAE450_Trajectory _Main.m if there are three stages and if the launch configuration is balloon or ground.
Input Section:
The call line of the script is:
AAE450_Trajectory_GSAC
Output Section:
The linear tangent steering law coefficients are defined based on the desired orientation of the rocket at the end of each stage and the burn time for each stage.
|Variable Name |Description |
|Steer_coeffs |[a_1temp b_1temp; a_2temp b_2temp; a_3temp b_3temp] |
Sample Output:
A sample ab.txt file is shown below. Note that the right column is a and the left column is b. The rows designate the stage.
-2.2410717e-001 2.8636253e+001
-1.6214735e-003 3.4671470e-001
0.0000000e+000 -1.7632698e-001
AAE450_Trajectory_GSAC_2STO.m
Written by Amanda Briden
Revision 1.0 – 16 March 2008
Description:
This script determines the steering angle coefficients for a linear tangent steering law for each stage of a balloon or ground launch. It then saves the coefficients to a text file called ab.txt.
Assumptions:
The desired steering angles at the end of each stage and the burn times for each stage are already defined.
Important Notes:
This script is only called in AAE450_Trajectory_Main.m if there are two stages and if the launch configuration is balloon or ground.
Input Section:
The call line of the script is:
AAE450_Trajectory_GSAC_2STO
Output Section:
The linear tangent steering law coefficients are defined based on the desired orientation of the rocket at the end of each stage and the burn time for each stage.
|Variable Name |Description |
|Steer_coeffs | [a_1temp b_1temp; a_2temp b_2temp] |
Sample Output:
A sample ab.txt file is shown below. Note that the right column is a and the left column is b. The rows designate the stage.
-2.2410717e-001 2.8636253e+001
-1.6214735e-003 3.4671470e-001
AAE450_Trajectory_GSAC_Aircraft_2_3linear_sections.m
Written by Amanda Briden
Revision 1.0 – 16 March 2008
Description:
This script determines the steering angle coefficients for the first and second stages of an aircraft launch (with the rocket initially positioned horizontally). A tangent steering law is applied to the first stage until the rocket is pointed to 88°. The second stage steering law is broken up into three linear parts. The coefficient a for the first stage steering law, the slope and intercept for the three linear sections of the second stage steering law, and the amount of time of the second stage burn time devoted to the first and second sections of the second stage linear steering laws are determined. These are saved in a text file called ab_AC2.txt in AAE450_Trajectoy_Main.m.
Assumptions:
The desired steering angles at the end of each stage, the burn times for each stage, and the percent of the 2nd stage burn time that the first linear portion of the steering law should be applied to are already defined.
Important Notes:
This script is only called in AAE450_Trajectoy_Main.m if there are two stages and if the launch configuration is aircraft.
Input Section:
The call line of the script is:
AAE450_Trajectory_GSAC_Aircraft_2_3linear_sections
Output Section:
The following variables create a continuous steering law.
|Variable Name |Description |
|a_1 |Coefficient defining the 1st stage tangent steering law |
|b_1 |This value is always zero. |
|a2_sec1 |Slope coefficient describing the 1st linear section of the 2nd stage linear steering law |
|a2_sec2 |Slope coefficient describing the 2nd linear section of the 2nd stage linear steering law |
|a2_sec3 |Slope coefficient describing the 3rd linear section of the 2nd stage linear steering law |
|b2_sec1 |Intercept coefficient describing the 1st linear section of the 2nd stage linear steering law |
|b2_sec2 |Intercept coefficient describing the 2nd linear section of the 2nd stage linear steering law |
|b2_sec3 |Intercept coefficient describing the 3rd linear section of the 2nd stage linear steering law |
|tb2sec1 |The amount of time of the second stage burn time devoted to the implementation of the second stage’s first linear |
| |steering law portion. |
|tb2sec2 |The amount of time of the second stage burn time devoted to the implementation of the second stage’s second linear |
| |steering law portion. |
Sample Output:
A sample ab_AC2.txt file is shown below. The order is as such:
tb2sec1 tb2sec2
a_1 b_1
a2_sec1 b2_sec1
a2_sec2 b2_sec2
a2_sec3 b2_sec3
8.0000000e+000 2.8000000e+001
1.9081137e+000 0.0000000e+000
-1.0864092e+001 8.7000000e+001
-4.3633231e-003 1.2217305e-001
-8.3910060e-003 2.3494817e-001
AAE450_Trajectory_GSAC_Aircraft_3.m
Written by Amanda Briden
Revision 1.0 – 16 March 2008
Description:
This script determines the steering angle coefficients for the third stage of an aircraft launch (with the rocket initially positioned horizontally). The third stage is a linear steering law that continues from the end of the second stage. The user can specify that the steering angle at the end of the second stage matches the end of the third, thus allowing for spin stabilization of the rocket’s third stage. The coefficient for the slope and intercept for the third stage are determined. These are appended to the end of the array specified in AAE450_Trajectory_GSAC_Aircraft_2_3linear_sections.m and the entire array is then saved in a text file called ab_AC3.txt in AAE450_Trajectory_Main.m.
Assumptions:
The desired steering angles at the end of the second and third stages, the burn times for the third stage should already be defined.
Important Notes:
This script is only called in AAE450_Trajectoy_Main.m if there are three stages and if the launch configuration is aircraft.
Input Section:
The call line of the script is:
AAE450_Trajectory_GSAC_Aircraft_3
Output Section:
The following variables create a continuous steering law.
|Variable Name |Description |
|a_3 |Coefficient defining the 3rd stage linear steering law |
|b_3 |Intercept coefficient describing the 3rd stage linear steering law |
Sample Output:
A sample ab_AC3.txt file is shown below. The order is as such (the other variables have been defined in the user guide for AAE450_Trajectory_GSAC_Aircraft_2_3linear_sections.m):
tb2sec1 tb2sec2
a_1 b_1
a2_sec1 b2_sec1
a2_sec2 b2_sec2
a2_sec3 b2_sec3
a_3 b_3
8.0000000e+000 2.8000000e+001
1.9081137e+000 0.0000000e+000
-1.0864092e+001 8.7000000e+001
-4.3633231e-003 1.2217305e-001
-8.3910060e-003 2.3494817e-001
2.1816616e-003 -4.3633231e-001
Delta_V.m
Written by Scott Breitengross
Revision 1.0 – 15 March 2008
Description:
This is the main function for calculating the values of ΔV. It uses the values obtained from the ODE functions, AAE450_Trajectory_Calculations.m or from the input values to calculate these.
Assumptions:
We assume the AAE450_Trajectory_Calculations.m has been completed.
Important Notes:
Most of the variables needed are output directly to the workspace so very few variables need to be created in order for the function to work.
Input Section:
The call line of the function is:
AAE450_Delta_V
Output Section:
These are the final determined values from this function which are displayed using AAE450_Trajectory_output.m
All of the variables that are passed into the function are described below:
|Variable Name |Description |
|Delta_V_Earth_assist |This is the ΔV due to the rotation of the Earth at the launch site. [m/s] |
|Delta_V_Leo |This is the velocity needed to get into the required orbit [m/s] |
|Delta_V_Grav |This is the ΔV due to gravity losses. [m/s] |
|deltaV_drag |This is the ΔV due to the drag. [m/s] |
|deltaV_thrust |This is the ΔV that the propulsion produces. [m/s] |
|Delta_V_Total |This is the ΔV that we need, not including the delta V to circularize. [m/s] |
AAE450_orbit_param.m
Written by Allen Guzik
Revision 1.0 – 24 March 2008
Description:
This program calculates various parameters that defines the orbit the trajectory code propagates.
Assumptions:
Keplerian two-body orbits, the Earth is a point, and Earth’s gravity is uniform throughout the duration of the orbit.
Input Section:
All of the variables that are passed into the function are described below:
|Variable Name |Description |
|r_dot_final |Final radial velocity of the vehicle at the end of the third stage |
| |[rad/s] |
|r_final |Final altitude of the vehicle at the end of the third stage. [m] |
|theta_dot_final |Final angular velocity of the vehicle at the end of the third stage. |
| |[rad/s] |
|phi_dot_final |Final angular velocity of the vehicle at the end of the third stage. |
| |[rad/s] |
|r_4 |Vector of the radius from the center of the Earth of the orbit |
| |propagation. [m] |
|mu |Gravitational parameter of the Earth. |
Output Section:
The orbit parameters calculated are:
|Variable Name |Description |
|rp |Orbit Periapsis [m] |
|ra |Orbit Apoapsis [m] |
|a |Orbit Semi-major Axis [m] |
|e |Orbit Eccentricity |
|energy |Orbit Energy [J/kg] |
|period |Orbit period [s] |
AAE450_Trajectory_outputs.m
Written by Junichi Kanehara
Revision 1.0 – 16 March 2008
Description:
This is a script to output the numerical values to the screen and to the file XX-XX-XX-XX.txt.
Assumptions:
We assume AAE450_Trajectory_Calculations.m has been run.
Input Section:
The call line of the function is:
AAE450_Trajectory_outputs
Output Section:
The output of AAE450_Trajectory_outputs.m is what creates the outputs for the entire trajectory code. A sample output for the code was given at the first section of this guide.
AAE450_Trajectory_Plots.m
Written by Junichi Kanehara
Revision 1.0 – 16 March 2008
Description:
This is a script that produces two-dimensional and three-dimensional plots.
Assumptions:
We assume all the numerical outputs from the entire code have been generated.
Important Notes:
It takes for a while (15-20 seconds) to get all the plots.
Input Section:
The call line of the function is:
AAE450_Trajectory_Plots
Some of the variables that are passed into the script are described below:
|Variable Name |Description |
|X |Position in the Cartesian coordinating system [m] |
|r |Radial position in the spherical coordinating system [m] |
|R_Earth |The radius of the Earth [m] |
|t |Time vector [s] |
Output Section:
Version 2.0 of this script generates three two-dimensional plots and two three-dimensional plots.
AAE450_Trajectory_Body2Inertial.m
Written by Junichi Kanehara
Revision 1.0 – 16 March 2008
Description:
This function converts from the body frame in the spherical coordinating system to the inertial frame in the Cartesian coordinating system.
Assumptions:
The origin is the center of the Earth.
Input Section:
The call line of the function is:
[X Y Z] = AAE450_Trajectory_Body2Inertial(r,phi,theta);
All of the variables that are passed into the function are described below:
|Variable Name |Description |
|r |Radial position from the center of the Earth [m] |
|phi |One component of angular position [rad] |
|theta |The other component of angular position [rad] |
Note: The example above is for the position, but we can also use this function for the velocity and the acceleration in the same unit vectors.
Output Section:
X, Y and Z describe the position in the Cartesian coordinating system from the center of the Earth. The unit will be the same as r, assuming phi and theta are in radians.
|Variable Name |Description |
|X |Position in the Cartesian coordinating system [m] |
|Y |Position in the Cartesian coordinating system [m] |
|Z |Position in the Cartesian coordinating system [m] |
Trajectory Code Flowchart: Run Once
Written by Kyle Donahue
Revision 1.0 – 24 March 2008
[pic]
[pic]
[pic]
Trajectory Code Flowchart: Optimize
Written by Scott Breitengross
Revision 1.0 – 24 March 2008
[pic]
[pic]
-----------------------
Propulsion and Structures Inputs
AAE_450_Trajectory_run. m
Launch Type
User Inputs(steering law angles)
Beginning of flight
End of 1st stage
End of 2nd stage
End of 3rd stage
User Inputs
Angle at end of climb
Fraction for first steering law
Angle at end of 2nd stage
Angle at end of 3rd stage
Main.m
Get_Inputs.m
Launch Type
# 0f Stages
AAE450_Trajectory_GSAC_
Aircraft_2_3linear_sections.m
# 0f Stages
AAE450_Trajectory_GSAC_
Aircraft_2_3linear_sections.m
AAE450_Trajectory_GSAC_
Aircraft_3.m
AAE450_Trajetory_Main.m
Ground/Balloon
Aircraft
2
3
2
3
Ground/Balloon
Aircraft
AAE450_Trajetory_Main.m
AAE450_Tracjetory_Calculations.m
_ODE
Type of
Launch
_ODE_Steer
_ODE_Steer
_ODE_AC_1st
Ground
Balloon
Aircraft
_ODE_Steer
_ODE_Steer
_ODE_AC_2nd
_ODE_AC_linear
_ODE_Steer
_ODE_Steer
_ODE_coast
AAE450_Tracjetory_Calculations.m
AAE450_Delta_V.m
AAE450_Delta_V.m
AAE450_Tracjetory_Calculations.m
AAE450_Trajectory_Main.m
_orbit_param
_Delta_V
_Ballistic_coeff
_Body2Inertial
_outputs
_plots
Propulsion and Structures Inputs
AAE_450_Trajectory_run_distribute.m
Launch Type
AAE450_Trajectory_D2MP.m
AAE450_Trajectory_D2MP_AC.m
AAE450_run_traj_Optimization_GB.m
AAE450_run_traj_Optimization_AC.m
Main.m
Get_Inputs.m
Launch Type
# 0f Stages
AAE450_Trajectory_GSAC_
Aircraft_2_3linear_sections.m
# 0f Stages
AAE450_Trajectory_GSAC_
Aircraft_2_3linear_sections.m
AAE450_Trajectory_GSAC_
Aircraft_3.m
AAE450_Trajectory_
GSAC_2STO.m
AAE450_Trajectory
_GSAC.m
AAE450_Trajetory_Main.m
Ground/Balloon
Aircraft
2
3
2
3
Ground/Balloon
Aircraft
AAE450_Trajetory_Main.m
Main.m
AAE450_Trajectory_Calculations.m
Launch Type
AAE450_Trajectory_ODE.m
Launch Type
AAE450_Trajectory_ODE_Steer.m
AAE450_Trajectory_ODE_AC_1st.m
AAE450_Trajectory_ODE_AC_2nd.m
AAE450_Trajectory_ODE_AC_linear.m
AAE450_Trajectory_ODE_coast.m
AAE450_Delta_V.m
AAE450_orbit_param.m
AAE450_Trajectory_Body2Ineritial.m
AAE450_Trajectory_Plots.m
Ground/Balloon
Aircraft
Ground/Balloon
Aircraft
................
................
In order to avoid copyright disputes, this page is only a partial summary.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.
Related download
- physics chapter 8 universal gravitation
- article managing your personal web
- user s guide to running the trajectory code using aae450
- honors chemistry spring 05 final exam study materials
- consiglio d area di ingegneria aerospaziale sapienza
- relating the turn angle to the change in longitude
- relativity4 department of physics
- home menifee county schools
- dynamics of atmospheric re entry ttu
Related searches
- beginners guide to the stock market
- guide to being a man s man
- man s guide to divorce
- a man s guide to women
- the complete guide to act grammar rules
- distance calculator for the trajectory equation
- men s guide to understanding women
- guide to the constitution
- guide to the stock market
- the teacher s guide wonders 2nd grade
- beginner s guide to social media
- write a program to ask the user to enter number of real numbers n then read in