API Reference

class AMAT.planet.Planet(planetID)

The Planet class is used to store planetary constants, load atmospheric data from look-up tables, and define non-dimensional parameters used in the simulations.

ID

String identifier of planet object

Type:

str

RP

Mean equatorial radius of the target planet in meters

Type:

float

OMEGA

Mean angular velocity of rotation of the planet about its axis of rotation in rad/s

Type:

float

GM

Standard gravitational parameter of the planet in m3/s2

Type:

float

rho0

Reference atmospheric density at the surface of the target planet in kg/m3

Type:

float

CPCV

Specific heat ratio CP/CV at the surface of the planet

Type:

float

J2

zonal harmonic coefficient J2

Type:

float

J3

zonal harmonic coefficient J3

Type:

float

a0

right ascension of North Pole in ICRF, rad

Type:

float

d0

declination of North Pole in ICRF, rad

Type:

float

h_thres

Atmospheric model cutoff altitude in meters, density is set to 0, if altitude exceeds h_thres

Type:

float

h_skip

If vehicle altitude exceeds this value, trajectory is cut off and vehicle is assumed to skip off the atmosphere

Type:

float

h_trap

If vehicle altitude falls below this value, trajectory is cut off and vehicle is assumed to hit the surface

Type:

float

h_low

If terminal altitude is below this value vehicle is assumed to be trapped in the atmosphere.

Type:

float

Vref

Reference velocity for non-dimensionalization of entry equations

Type:

float

tau

Reference timescale used to non-dimensionalize time, angular rates

Type:

float

OMEGAbar

Reference non-dimensional angular rate of planet’s rotation

Type:

float

EARTHG

Reference value of acceleration due to Earth’s gravity

Type:

float

ATM

Array containing the data loaded from atmospheric lookup file

Type:

numpy.ndarray

ATM_height

Array containing height values from atm. look up dat file

Type:

numpy.ndarray

ATM_temp

Array containing temperature values from atm. look up dat file

Type:

numpy.ndarray

ATM_pressure

Array containing pressure values from atm. look up dat file

Type:

numpy.ndarray

ATM_density

Array containing density values from atm. look up dat file

Type:

numpy.ndarray

ATM_sonic

Array containing computed sonic speed values

Type:

numpy.ndarray

temp_int

Function which interpolates temperature as function of height

Type:

scipy.interpolate.interpolate.interp1d

pressure_int

Function which interpolates pressure as function of height

Type:

scipy.interpolate.interpolate.interp1d

density_int

Function which interpolates density as function of height

Type:

scipy.interpolate.interpolate.interp1d

sonic_int

Function which interpolates sonic speed as function of height

Type:

scipy.interpolate.interpolate.interp1d

avectorized(h)

Returns atmospheric sonic speed, vector at altitudes array h[:] in meters

Parameters:

h (numpy.ndarray) – altitude h[:] at which sonic speed is desired

Returns:

ans – returns the sonic speed at altitudes h[:], K

Return type:

numpy.ndarray

checkAtmProfiles(h0=0.0, dh=1000.0)

Function to check the loaded atmospheric profile data. Plots temperature, pressure, density and sonic speed as function of altitude.

Parameters:

  • h0 (float, optional) – lower limit of altitude, defaults to 0.0

  • dh (float, optional) – height interval

Returns:

  • A plot showing the atmospheric profiles loaded

  • from the lookup tables

computeH(r)

Returns altitude h, as a function of radial distance r, METERS

Parameters:

r (float) – radial distance in meters

Returns:

h – h = r - RP

Return type:

float

computeR(h)

Returns radial distance r, as a function of altitude h, METERS

Parameters:

h (float) – altitude in meters

Returns:

r – radial distance r=RP+h

Return type:

float

density(h)

Returns atmospheric density, scalar value, at altitude h (in meters)

Parameters:

h (float) – altitude in meters

Returns:

ans – atmospheric density at height h

Return type:

float

densityvectorized(h)

Returns atmospheric density, vector at altitudes array h[:] in meters

Parameters:

h (numpy.ndarray) – altitude h[:] at which atmospheric density is desired

Returns:

ans – returns the atmospheric density at altitudes h[:], K

Return type:

numpy.ndarray

dimensionalize(tbar, rbar, theta, phi, vbar, psi, gamma, drangebar)

Computes dimensional trajectory state variables from non-dimensional trajectory state variables

Parameters:

  • rbar (float) – non-dimensional radial distance in meters

  • theta (float) – longitude theta(RADIANS), theta in [-PI,PI]

  • phi (float) – latitude phi (RADIANS), phi in (-PI/2, PI/2)

  • vbar (float) – non-dimensional planet-relative speed, m/s

  • psi (float) – heading angle, radians

  • gamma (float) – planet-relative flight-path angle, radians

  • drangebar (float) – non-dimensional downrange distance measured from entry-interface

Returns:

  • r (float) – radial distance in meters

  • theta (float) – longitude theta(RADIANS), theta in [-PI,PI]

  • phi (float) – latitude phi (RADIANS), phi in (-PI/2, PI/2)

  • v (float) – planet-relative speed, m/s

  • psi (float) – heading angle, radians

  • gamma (float) – planet-relative flight-path angle, radians

  • drange (float) – downrange distance measured from entry-interface

loadAtmosphereModel(datfile, heightCol, tempCol, presCol, densCol, intType='cubic', heightInKmFlag=False)

Load atmospheric model from a look up table with height, temperature, pressure, and density

Parameters:

  • datfile (str) – file containing atmospheric lookup table

  • heightCol (int) – column number of height values, assumes unit = meters (first column = 0, second column = 1, etc.)

  • tempCol (int) – column number of temperature values, assumes unit = K (first column = 0, second column = 1, etc.)

  • presCol (int) – column number of pressure values, assumes unit = Pascals (first column = 0, second column = 1, etc.)

  • densCol (int) – column number of density values, assumes unit = kg/m3 (first column = 0, second column = 1, etc.)

  • intType (str, optional) – interpolation type: ‘linear’, ‘quadratic’ or ‘cubic’ defaults to ‘cubic’

  • heightInKmFlag (bool, optional) – optional, set this to True if heightCol has units of km, False by default

loadAtmosphereModel5(ATM_height, ATM_density_low, ATM_density_avg, ATM_density_high, ATM_density_pert, sigmaValue, NPOS, i)

Read and create density_int for a single entry from a list of perturbed monte carlo density profiles.

Parameters:

  • ATM_height (numpy.ndarray) – height array, m

  • ATM_density_low (numpy.ndarray) – low density array, kg/m3

  • ATM_density_avg (numpy.ndarray) – avg. density array, kg/m3

  • ATM_density_high (numpy.ndarray) – high density array, kg/m3

  • ATM_density_pert (numpy.ndarray) – 1 sigma mean deviation from avg

  • sigmaValue (float) – mean desnity profile sigma deviation value (intended as input from a normal distribution with mean=0, sigma=1)

  • NPOS (int) – NPOS value from GRAM model equals the number of positions (altitude) for which density value is available in look up table.

  • i (int) – index of atmospheric profile to load

Returns:

density_int – density interpolation function

Return type:

scipy.interpolate.interpolate.interp1d

loadAtmosphereModel6(ATM_height, ATM_density_low, ATM_density_avg, ATM_density_high, sigmaValue, NPOS, i)

Read and create mean density profile for a single entry from a list of perturbed monte carlo density profiles.

Parameters:

  • ATM_height (numpy.ndarray) – height array, m

  • ATM_density_low (numpy.ndarray) – low density array, kg/m3

  • ATM_density_avg (numpy.ndarray) – avg. density array, kg/m3

  • ATM_density_high (numpy.ndarray) – high density array, kg/m3

  • sigmaValue (float) – mean desnity profile sigma deviation value (intended as input from a normal distribution with mean=0, sigma=1)

  • NPOS (int) – NPOS value from GRAM model equals the number of positions (altitude) for which density value is available in look up table.

  • i (int) – index of atmospheric profile to load

Returns:

density_int – density interpolation function

Return type:

scipy.interpolate.interpolate.interp1d

loadMonteCarloDensityFile2(atmfile, heightCol, densLowCol, densAvgCol, densHighCol, densTotalCol, heightInKmFlag=False)

Loads a Monte Carlo density look up table from GRAM-Model output

Parameters:

  • atmfile (str) – filename, contains mean density profile data

  • heightCol (int) – column number of height values, assumes unit = meters (first column = 0, second column = 1, etc.)

  • densLowCol (int) – column number of the low mean density

  • densAvgCol (int) – column number of the average mean density

  • densHighCol (int) – column number of the high mean desnity

  • densTotalCol (int) – column number of the total (=mean + perturb.) density

  • heightInKmFlag (bool, optional) – optional, set this to True if heightCol has units of km, False by default

Returns:

  • ATM_height (numpy.ndarray) – height array, m

  • ATM_density_low (numpy.ndarray) – low density array, kg/m3

  • ATM_density_avg (numpy.ndarray) – avg. density array, kg/m3

  • ATM_density_high (numpy.ndarray) – high density array, kg/m3

  • ATM_density_pert (numpy.ndarray) – 1 sigma mean deviation from avg

loadMonteCarloDensityFile3(atmfile, heightCol, densAvgCol, densSD_percCol, densTotalCol, heightInKmFlag=False)

Loads a Monte Carlo density look up table from GRAM-Model output, Utility function for EARTH-GRAM atmospheric data

Parameters:

  • atmfile (str) – filename, contains mean density profile data

  • heightCol (int) – column number of height values, assumes unit = meters (first column = 0, second column = 1, etc.)

  • densAvgCol (int) – column number of the average mean density

  • densSD_percCol (int) – column number of mean density one sigma SD

  • densTotalCol (int) – column number of the total (=mean + perturb.) density

  • heightInKmFlag (bool, optional) – optional, set this to True if heightCol has units of km, False by default

Returns:

  • ATM_height (numpy.ndarray) – height array, m

  • ATM_density_low (numpy.ndarray) – low density array, kg/m3

  • ATM_density_avg (numpy.ndarray) – avg. density array, kg/m3

  • ATM_density_high (numpy.ndarray) – high density array, kg/m3

  • ATM_density_pert (numpy.ndarray) – 1 sigma mean deviation from avg

nSigmaFunc(x)

Utility function. Returns 1 if x<0, 0.0 otherwise

Parameters:

x (float) – input x

Returns:

ans – 1 if x<0, 0.0 otherwise

Return type:

float

nonDimState(r, theta, phi, v, psi, gamma, drange)

Computes non-dimensional trajectory state variables from dimensional trajectory state variables

Parameters:

  • r (float) – radial distance in meters

  • theta (float) – longitude theta(RADIANS), theta in [-PI,PI]

  • phi (float) – latitude phi (RADIANS), phi in (-PI/2, PI/2)

  • v (float) – planet-relative speed, m/s

  • psi (float) – heading angle, radians

  • gamma (float) – planet-relative flight-path angle, radians

  • drange (float) – downrange distance measured from entry-interface

Returns:

  • rbar (float) – non-dimensional radial distance in meters

  • theta (float) – longitude theta(RADIANS), theta in [-PI,PI]

  • phi (float) – latitude phi (RADIANS), phi in (-PI/2, PI/2)

  • vbar (float) – non-dimensional planet-relative speed, m/s

  • psi (float) – heading angle, radians

  • gamma (float) – planet-relative flight-path angle, radians

  • drangebar (float) – non-dimensional downrange distance measured from entry-interface

pSigmaFunc(x)

Utility function. Returns 1 if x>=0, 0.0 otherwise

Parameters:

x (float) – input x

Returns:

ans – 1 if x>=0, 0.0 otherwise

Return type:

float

pressurevectorized(r)

Returns atmospheric pressure, vector at radial distance array r[:] in meters

Parameters:

r (numpy.ndarray) – radial distance r[:] at which pressure is desired

Returns:

ans – returns the atmospheric pressure at radial distance r[:]

Return type:

numpy.ndarray

presvectorized(h)

Returns atmospheric pressure, vector at altitudes array h[:] in meters

Parameters:

h (numpy.ndarray) – altitude h[:] at which atmospheric pressure is desired

Returns:

ans – returns the atmospheric pressure at altitudes h[:], K

Return type:

numpy.ndarray

rbar(r)

Returns non-dimensional rbar=r/RP

Parameters:

r (float) – radial distance in meters

Returns:

ans – non-dimensional rbar

Return type:

float

rho(r, theta, phi)

Returns atmospheric density rho, scalar, as a function of radial distance from the target planet center r as well as longitude theta and latitude phi

Parameters:

  • r (float) – radial distance r measured from the planet center

  • theta (float) – longitude theta(RADIANS), theta in [-PI,PI]

  • phi (float) – latitude phi (RADIANS), phi in (-PI/2, PI/2)

Returns:

ans – returns the atmospheric density at (r,theta,phi)

Return type:

numpy.ndarray

rho2(rbar, theta, phi)

Returns atmospheric density rho, scalar, as a function of non-dimensional radial distance rbar, longitude theta, and latitude phi

Parameters:

  • rbar (float) – nondimensional radial distance rbar measured from the planet center

  • theta (float) – longitude theta(RADIANS), theta in [-PI,PI]

  • phi (float) – latitude phi (RADIANS), phi in (-PI/2, PI/2)

Returns:

ans – returns the atmospheric density at (rbar,theta,phi)

Return type:

float

rhobar(rbar, theta, phi)

Returns non-dimensional density rhobar = rho / rho0 as a function of non-dimensional radial distance rbar, longitude theta, and latitude phi

Parameters:

  • rbar (float) – nondimensional radial distance rbar measured from the planet center

  • theta (float) – longitude theta(RADIANS), theta in [-PI,PI]

  • phi (float) – latitude phi (RADIANS), phi in (-PI/2, PI/2)

Returns:

ans – non-dimensional density at (rbar,theta,phi)

Return type:

float

rhovectorized(r)

Returns atmospheric density, vector at radial distance array r[:] in meters

Parameters:

r (numpy.ndarray) – radial distance r[:] at which density is desired

Returns:

ans – returns the atmospheric density at radial distance r[:]

Return type:

numpy.ndarray

scaleHeight(h, density_int)

Returns the scale height as a function of altitude for given density profile

Parameters:

  • h (float) – altitude at which scale height is desired

  • density_int (scipy.interpolate.interpolate.interp1d) – density interpolation function

  • -- –

Returns:

ans – scale height, meters

Return type:

float

sonicvectorized(r)

Returns atmospheric sonic speed, vector at radial distance array r[:] in meters

Parameters:

r (numpy.ndarray) – radial distance r[:] at which sonic speed is desired

Returns:

ans – returns the atmospheric speed at radial distance r[:]

Return type:

numpy.ndarray

temperaturevectorized(r)

Returns atmospheric temperature, vector at radial distance array r[:] in meters

Parameters:

r (numpy.ndarray) – radial distance r[:] at which temperature is desired

Returns:

ans – returns the atmospheric temperature at radial distance r[:]

Return type:

numpy.ndarray

tempvectorized(h)

Returns atmospheric temperature, vector at altitudes array h[:] in meters

Parameters:

h (numpy.ndarray) – altitude h[:] at which atmospheric temperature is desired

Returns:

ans – returns the atmospheric temperature at altitudes h[:], K

Return type:

numpy.ndarray

class AMAT.vehicle.Vehicle(vehicleID, mass, beta, LD, A, alpha, RN, planetObj, userDefinedCDMach=False)

The Vehicle class is used to define vehicle parameters, such as mass, aerodynamics, and aeroheating relations.

vehicleID

identifier string for vehicle object

Type:

str

mass

vehicle mass, kg

Type:

float

beta

vehicle ballistic coefficient, kg/m2

Type:

float

LD

vehicle lift-to-drag ratio

Type:

float

A

vehicle reference aerodynamic area, m2

Type:

float

alpha

vehicle angle-of-attack, currently not implemented, rad

Type:

float

RN

vehicle nose-radius, m

Type:

float

planetObj

planet object associated with the vehicle, indicates the planetary atmosphere in which the vehicle will operate in

Type:

planet.Planet

Abar

vehicle non-dimensional reference area

Type:

float

mbar

vehicle non-dimensional mass

Type:

float

CD

vehicle drag coefficient

Type:

float

CL

vehicle lift coefficient

Type:

float

h0_km

initial vehicle altitude at atmospheric interface / other start point, meters

Type:

float

theta0_deg

initial vehicle longitude at atmospheric interface / other start point, degrees

Type:

float

phi0_deg

initial vehicle latitude at atmospheric interface / other start point, degrees

Type:

float

v0_kms

initial vehicle speed (planet-relative) at atmospheric interface / other start point, km/s

Type:

float

psi0_deg

initial vehicle heading at atmospheric interface / other start point, degrees

Type:

float

gamma0_deg

initial vehicle flight-path angle at atmospheric interface / other start point, degrees

Type:

float

drange0_km

initial vehicle downrange at atmospheric interface / other start point, km

Type:

float

heatLoad0

initial vehicle heatload at atmospheric interface / other start point, J/cm2

Type:

float

tol

solver tolerance, currently both abstol and reltol are set to this value

Type:

float

index

array index of the event location if one was detected, terminal index otherwise

Type:

int

exitflag

flag to indicate and classify event occurence or lack of it

Type:

int

tc

truncated time array, sec

Type:

numpy.ndarray

rc

truncated radial distance array, m

Type:

numpy.ndarray

thetac

truncated longitude solution array, rad

Type:

numpy.ndarray

phic

truncated latitude solution, rad

Type:

numpy.ndarray

vc

truncated speed solution array, m/s

Type:

numpy.ndarray

psic

truncated heading angle solution, rad

Type:

numpy.ndarray

gammac

truncated flight-path angle solution, rad

Type:

numpy.ndarray

drangec

truncated downrange solution array, m

Type:

numpy.ndarray

t_minc

truncated time array, minutes

Type:

numpy.ndarray

h_kmc

truncated altitude array, km

Type:

numpy.ndarray

v_kmsc

truncated speed array, km/s

Type:

numpy.ndarray

phi_degc

truncated latitude array, deg

Type:

numpy.ndarray

psi_degc

truncated heading angle, deg

Type:

numpy.ndarray

theta_degc

truncated longitude array, deg

Type:

numpy.ndarray

gamma_degc

truncared flight-path angle array, deg

Type:

numpy.ndarray

drange_kmc

truncated downrange array, km

Type:

numpy.ndarray

acc_net_g

acceleration load solution, Earth G

Type:

numpy.ndarray

acc_drag_g

drag acceleration solution, Earth G

Type:

numpy.ndarray

dyn_pres_atm

dynamic pressure solution, Pa

Type:

numpy.ndarray

stag_pres_atm

stagnation pressure solution, Pa

Type:

numpy.ndarray

q_stag_con

stagnation-point convective heat rate, W/cm2

Type:

numpy.ndarray

q_stag_rad

stagnation-point radiative heat rate, W/cm2

Type:

numpy.ndarray

q_stag_total

stagnation-point radiative tottal heat rate, W/cm2

Type:

numpy.ndarray

heatload

stagnation point heat load, J/cm2

Type:

numpy.ndarray

maxRollRate

maximum allowed roll rate, degrees per second

Type:

float

beta1

beta1 (smaller ballistic coeff.) for drag modulation, kg/m2

Type:

float

betaRatio

ballistic coefficient ratio for drag modulation

Type:

float

target_peri_km

vehicle target periapsis altitude, km

Type:

float

target_apo_km

vehicle target apoapsis altitude, km

Type:

float

target_apo_km_tol

vehicle target apoapsis altitude error tolerance, km used by guidance algorithm

Type:

float

Ghdot

Ghdot term for vehicle equilibrium glide phase

Type:

float

Gq

Gq term for vehicle equilibrium glide phase guidance

Type:

float

v_switch_kms

speed below which eq. glide phase is terminated

Type:

float

t_step_array

time step array for guided aerocapture trajectory, min

Type:

numpy.ndarray

delta_deg_array

bank angle array for guided aerocapture trajectory, deg

Type:

numpy.ndarray

hdot_array

altitude rate array for guided aerocapture trajectory, m/s

Type:

numpy.ndarray

hddot_array

altitude acceleration array for guided aerocapture, m/s2

Type:

numpy.ndarray

qref_array

reference dynamic pressure array for guided aerocapture, Pa

Type:

numpy.ndarray

q_array

actual dynamic pressure array for guided aerocapture, Pa

Type:

numpy.ndarray

h_step_array

altitude array for guided aerocapture, meters

Type:

numpy.ndarray

acc_step_array

acceleration array for guided aerocapture, Earth G

Type:

numpy.ndarray

acc_drag_array

acceleration due to drag for guided aerocapture, Earth G

Type:

numpy.ndarray

density_mes_array

measured density array during descending leg, kg/m3

Type:

numpy.ndarray

density_mes_int

measured density interpolation function

Type:

scipy.interpolate.interpolate.interp1d

minAlt

minimum altitude at which density measurement is available, km

Type:

float

lowAlt_km

lower altitude to which density model is to be extrapolated based on available measurements, km

Type:

float

numPoints_lowAlt

number of points to evaluate extrapolation at below the altitude where measurements are available

Type:

int

hdot_threshold

threshold altitude rate (m/s) above which density measurement is terminated and apoapsis prediction is initiated

Type:

float

t_min_eg

time solution of equilibrium glide phase, min

Type:

numpy.ndarray

h_km_eg

altitude array of equilibrium glide phase, km

Type:

numpy.ndarray

v_kms_eg

speed solution of equilibrium glide phase, km/s

Type:

numpy.ndarray

theta_deg_eg

longitude solution of equilibrium glide phase, deg

Type:

numpy.ndarray

phi_deg_eg

latitude solution of equilibrium glide phase, deg

Type:

numpy.ndarray

psi_deg_eg

heading angle solution of equilibrium glide phase, deg

Type:

numpy.ndarray

gamma_deg_eg

flight-path angle solution of eq. glide phase, deg

Type:

numpy.ndarray

drange_km_eg

downrange solution of eq. glide phase, km

Type:

numpy.ndarray

acc_net_g_eg

acceleration solution of eq. glide phase, Earth G

Type:

numpy.ndarray

dyn_pres_atm_eg

dynamic pressure solution of eq. glide phase, atm

Type:

numpy.ndarray

stag_pres_atm_eg

stagnation pressure solution of eq. glide phase, atm

Type:

numpy.ndarray

q_stag_total_eg

stag. point total heat rate of eq. glide phase, W/cm2

Type:

numpy.ndarray

heatload_eg

stag. point heatload solution of eq. glide phase, J/cm2

Type:

numpy.ndarray

t_switch

swtich time from eq. glide to exit phase, min

Type:

float

h_switch

altitude at which guidance switched to exit phase, km

Type:

float

v_switch

speed at which guidance switched to exit phase, km/s

Type:

float

p_switch

bank angle at which guidance switched to exit phase, deg

Type:

float

t_min_full

time solution of full (eq. gllide + exit phase), min

Type:

numpy.ndarray

h_km_full

altitude array of full (eq. gllide + exit phase), km

Type:

numpy.ndarray

v_kms_full

speed solution of full (eq. gllide + exit phase), km/s

Type:

numpy.ndarray

theta_deg_full

longitude solution of full (eq. gllide + exit phase), deg

Type:

numpy.ndarray

phi_deg_full

latitude solution of full (eq. gllide + exit phase), deg

Type:

numpy.ndarray

psi_deg_full

heading angle solution of full (eq. gllide + exit phase), deg

Type:

numpy.ndarray

gamma_deg_full

flight-path angle solution of full (eq. gllide + exit phase), deg

Type:

numpy.ndarray

drange_km_full

downrange solution of full (eq. gllide + exit phase), km

Type:

numpy.ndarray

acc_net_g_full

acceleration solution of full (eq. gllide + exit phase), Earth G

Type:

numpy.ndarray

dyn_pres_atm_full

dynamic pressure solution of full (eq. gllide + exit phase), atm

Type:

numpy.ndarray

stag_pres_atm_full

stagnation pressure solution of full (eq. gllide + exit phase), atm

Type:

numpy.ndarray

q_stag_total_full

stag. point total heat rate of full (eq. gllide + exit phase), W/cm2

Type:

numpy.ndarray

heatload_full

stag. point heatload solution of full (eq. gllide + exit phase), J/cm2

Type:

numpy.ndarray

NPOS

NPOS value from GRAM model output is the number of data points (altitude) in each atm. profile

Type:

int

NMONTE

NMONTE is the number of Monte Carlo atm profiles from GRAM model output

Type:

int

heightCol

column number of altitude values in Monte Carlo density file

Type:

int

densLowCol

column number of low density value in Monte Carlo density file

Type:

int

densAvgCol

column number of avg. density value in Monte Carlo density file

Type:

int

densHighCol

column number of high density value in Monte Carlo density file

Type:

int

densTotalCol

column number of total density value in Monte Carlo density file

Type:

int

heightInKmFlag

set to True if height values are in km

Type:

bool

nominalEFPA

nominal entry-flight-path angle

Type:

float

EFPA_1sigma_value

1-sigma error for EFPA

Type:

float

nominalLD

nominal vehicle lift-to-drag ratio

Type:

float

LD_1sigma_value

1-sigma error for vehicle lift-to-drag ratio

Type:

float

vehicleCopy

copy of the original vehicle object

Type:

Vehicle.vehicle

timeStep

guidance cycle time, sec

Type:

float

dt

max. solver timestep, sec

Type:

float

maxTimeSecs

maximum propogation time used by guidance algorithm, sec

Type:

float

t_min_en

time solution of entry phase (DM), min

Type:

numpy.ndarray

h_km_en

altitude solution of entry phase (DM), km

Type:

numpy.ndarray

v_kms_en

velocity solution of entry phase (DM), km/s

Type:

numpy.ndarray

theta_deg_en

longitude solution of entry phase (DM), deg

Type:

numpy.ndarray

phi_deg_en

latitude solution of entry phase (DM), deg

Type:

numpy.ndarray

psi_deg_en

heading angle solution of entry phase (DM), deg

Type:

numpy.ndarray

gamma_deg_en

FPA solution of entry phase (DM), deg

Type:

numpy.ndarray

drange_km_en

downrange solution of entry phase (DM), km

Type:

numpy.ndarray

acc_net_g_en

acceleration solution of entry phase, Earth g

Type:

numpy.ndarray

dyn_pres_atm_en

dynamic pressures solution of entry phase, atm

Type:

numpy.ndarray

stag_pres_atm_en

stagnation pressure solution of entry phase, atm

Type:

numpy.ndarray

q_stag_total_en

heat rate solution of entry phase, W/cm2

Type:

numpy.ndarray

heatload_en

heatload solution of entry phase, J/cm2

Type:

float

userDefinedCDMach

if set to True, will use a user defined function for CD(Mach) set by setCDMachFunction(), default=False

Type:

bool

D(r, theta, phi, v)

Computes the vehicle aerodynamic drag, as a function of the vehicle location(r,theta, phi), and velocity.

Parameters:

  • r (float) – radial position value, scalar, m

  • theta (float) – longitude, radians

  • phi (float) – latitude, radians

  • v (float) – planet-relative speed, m/s

Returns:

ans – aerodynamic drag force, N

Return type:

float

Dbar(rbar, theta, phi, vbar)

Computes the non-dimensional vehicle aerodynamic drag, as a function of the vehicle location(r,theta, phi), and velocity.

Parameters:

  • rbar (float) – non-dimensional radial position

  • theta (float) – longitude, radians

  • phi (float) – latitude, radians

  • vbar (float) – non-dimensional planet-relative speed, m/s

Returns:

ans – non-dimensional aerodynamic drag force

Return type:

float

Dvectorized(r, theta, phi, v)

Vectorized version of the D() function

Computesthe vehicle aerodynamic drag array over the provided trajectory array, as a function of the vehicle location array (r[:],theta[:], phi[:]), and velocity.

Parameters:

  • r (numpy.ndarray) – radial position array, m

  • theta (numpy.ndarray) – longitude array, radians

  • phi (numpy.ndarray) – latitude array, radians

  • v (numpy.ndarray) – planet-relative speed array, m/s

Returns:

ans – aerodynamic drag force array, N

Return type:

numpy.ndarray

EOM(y, t, delta)

Define the EoMs to propogate the 3DoF trajectory inside the atmosphere of a an oblate rotating planet.

Reference 1: Vinh, Chapter 3. Reference 2: Lescynzki, MS Thesis, NPS.

Parameters:

  • y (numpy.ndarray) – trajectory state vector

  • t (numpy.ndarray) – trajectory time vector

  • delta (float) – bank angle, rad

Returns:

ans – derivate vector of state, process equations

Return type:

dydt

EOM2(t, y, delta)

Define the EoMs to propogate the 3DoF trajectory inside the atmosphere of a an oblate rotating planet.

Reference 1: Vinh, Chapter 3. Reference 2: Lescynzki, MS Thesis, NPS.

Parameters:

  • y (numpy.ndarray) – trajectory state vector

  • t (numpy.ndarray) – trajectory time vector

  • delta (float) – bank angle, rad

Returns:

ans – derivate vector of state, process equations

Return type:

dydt

L(r, theta, phi, v)

Computes the vehicle aerodynamic lift, as a function of the vehicle location(r,theta, phi), and velocity.

Parameters:

  • r (float) – radial position value, scalar, m

  • theta (float) – longitude, radians

  • phi (float) – latitude, radians

  • v (float) – planet-relative speed, m/s

Returns:

ans – aerodynamic lift force, N

Return type:

float

Lbar(rbar, theta, phi, vbar)

Computes the non-dimensional vehicle aerodynamic lift, as a function of the vehicle location(r,theta, phi), and velocity.

Parameters:

  • rbar (float) – non-dimensional radial position

  • theta (float) – longitude, radians

  • phi (float) – latitude, radians

  • vbar (float) – non-dimensional planet-relative speed, m/s

Returns:

ans – non-dimensional aerodynamic lift force

Return type:

float

Lvectorized(r, theta, phi, v)

Vectorized version of the L() function

Computesthe vehicle aerodynamic lift array over the provided trajectory array, as a function of the vehicle location array (r[:],theta[:], phi[:]), and velocity.

Parameters:

  • r (numpy.ndarray) – radial position array, m

  • theta (numpy.ndarray) – longitude array, radians

  • phi (numpy.ndarray) – latitude array, radians

  • v (numpy.ndarray) – planet-relative speed array, m/s

Returns:

ans – aerodynamic lift force array, N

Return type:

numpy.ndarray

a_n(r, theta, phi, v, delta)

Function to return normal acceleration term a_n;

a_n is the normal acceleration term along perpendicular to the velocity vector, in the plane of the trajectory.

Current formulation does not include thrust, can be added here later in place of 0.0

Parameters:

  • r (float) – radial position value, scalar, m

  • theta (float) – longitude, radians

  • phi (float) – latitude, radians

  • v (float) – planet-relative speed, m/s

  • delta (float) – bank angle, rad

Returns:

ans – normal acceleration term a_n

Return type:

float

a_nbar(rbar, theta, phi, vbar, delta)

Function to return non-dimensional normall acceleration term a_nbar;

a_nbar is the tangential acceleration term along the direction of the velocity vector.

Current formulation does not include thrust, can be added here later in place of 0.0

Parameters:

  • rbar (float) – non-dimensional radial position

  • theta (float) – longitude, radians

  • phi (float) – latitude, radians

  • vbar (float) – non-dimensional planet-relative speed, m/s

  • delta (float) – bank angle, rad

Returns:

ans – non-dimensional tangential acceleration term a_nbar

Return type:

float

a_nvectorized(r, theta, phi, v, delta)

Vectorized version of the a_n() function

Parameters:

  • r (numpy.ndarray) – radial position array, m

  • theta (numpy.ndarray) – longitude array, radians

  • phi (numpy.ndarray) – latitude array, radians

  • v (numpy.ndarray) – planet-relative speed array, m/s

  • delta (float) – bank angle, rad

Returns:

ans – normal acceleration array, m/s2

Return type:

numpy.ndarray

a_s(r, theta, phi, v, delta)

Function to return tangential acceleration term a_s;

a_s is the tangential acceleration term along the direction of the velocity vector.

Current formulation does not include thrust, can be added here later in place of 0.0

Parameters:

  • r (float) – radial position value, scalar, m

  • theta (float) – longitude, radians

  • phi (float) – latitude, radians

  • v (float) – planet-relative speed, m/s

  • delta (float) – bank angle, rad

Returns:

ans – tangential acceleration term a_s

Return type:

float

a_sbar(rbar, theta, phi, vbar, delta)

Function to return non-dimensional tangential acceleration term a_sbar;

a_sbar is the tangential acceleration term along the direction of the velocity vector.

Current formulation does not include thrust, can be added here later in place of 0.0

Parameters:

  • rbar (float) – non-dimensional radial position

  • theta (float) – longitude, radians

  • phi (float) – latitude, radians

  • vbar (float) – non-dimensional planet-relative speed, m/s

  • delta (float) – bank angle, rad

Returns:

ans – non-dimensional tangential acceleration term a_sbar

Return type:

float

a_svectorized(r, theta, phi, v, delta)

Vectorized version of the a_s() function

Parameters:

  • r (numpy.ndarray) – radial position array, m

  • theta (numpy.ndarray) – longitude array, radians

  • phi (numpy.ndarray) – latitude array, radians

  • v (numpy.ndarray) – planet-relative speed array, m/s

  • delta (float) – bank angle, rad

Returns:

ans – tangential acceleration array, m/s2

Return type:

numpy.ndarray

a_w(r, theta, phi, v, delta)

Function to return binormal acceleration term a_w;

a_n is the binormal acceleration term along perpendicular to the velocity vector, perpendicular to the plane of the trajectory.

Current formulation does not include thrust, can be added here later in place of 0.0

Parameters:

  • r (float) – radial position value, scalar, m

  • theta (float) – longitude, radians

  • phi (float) – latitude, radians

  • v (float) – planet-relative speed, m/s

  • delta (float) – bank angle, rad

Returns:

ans – binormal acceleration term a_n

Return type:

float

a_wbar(rbar, theta, phi, vbar, delta)

Function to return non-dimensional normal acceleration term a_wbar;

a_wbar is the tangential acceleration term along the direction of the velocity vector.

Current formulation does not include thrust, can be added here later in place of 0.0

Parameters:

  • rbar (float) – non-dimensional radial position

  • theta (float) – longitude, radians

  • phi (float) – latitude, radians

  • vbar (float) – non-dimensional planet-relative speed, m/s

  • delta (float) – bank angle, rad

Returns:

ans – non-dimensional tangential acceleration term a_wbar

Return type:

float

a_wvectorized(r, theta, phi, v, delta)

Vectorized version of the a_w() function

Parameters:

  • r (numpy.ndarray) – radial position array, m

  • theta (numpy.ndarray) – longitude array, radians

  • phi (numpy.ndarray) – latitude array, radians

  • v (numpy.ndarray) – planet-relative speed array, m/s

  • delta (float) – bank angle, rad

Returns:

ans – binormal acceleration array, m/s2

Return type:

numpy.ndarray

cfgammabar(rbar, phi, vbar, psi, gamma)

Function to return non dimensional centrifugal acceleration term cfgammabar

cfgammabar is the non dimensional centrifugal acceleration term in the EOM

Parameters:

  • rbar (float) – non-dimensional radial position

  • phi (float) – latitude, radians

  • vbar (float) – non-dimensional planet-relative speed, m/s

  • psi (float) – heading angle, rad

  • gamma (float) – flight-path angle, rad

Returns:

ans – non dimensional centrifugal acceleration cfpsibar

Return type:

float

cfpsibar(rbar, phi, vbar, psi, gamma)

Function to return non dimensional centrifugal acceleration term cfpsibar

cfpsibar is the non dimensional centrifugal acceleration term in the EOM

Parameters:

  • rbar (float) – non-dimensional radial position

  • phi (float) – latitude, radians

  • vbar (float) – non-dimensional planet-relative speed, m/s

  • psi (float) – heading angle, rad

  • gamma (float) – flight-path angle, rad

Returns:

ans – non dimensional centrifugal acceleration cfpsibar

Return type:

float

cfvbar(rbar, phi, vbar, psi, gamma)

Function to return non dimensional centrifugal acceleration term cfvbar

cfvbar is the non dimensional centrifugal acceleration term cfvbar in the EOM

Parameters:

  • rbar (float) – non-dimensional radial position

  • phi (float) – latitude, radians

  • vbar (float) – non-dimensional planet-relative speed, m/s

  • psi (float) – heading angle, rad

  • gamma (float) – flight-path angle, rad

Returns:

ans – non dimensional centrifugal acceleration cfvbar

Return type:

float

classifyTrajectory(r)

This function checks the trajectory for “events” which are used to truncate the trajectory

A “skip out event” is said to occur as when the vehicle altitude did not hit the surface and exceeds the prescribed skip out altitude.

A “time out event” is said to occur if the vehicle did not exceed the skip out altitude, and did not reach the trap in altitude.

A “trap in” event is said to occur when the vehicle altitude falls below the prescribed trap in altitude.

This function checks for these events and returns the array index of the “event” location and an exitflag

exitflag to indicate if an event was detected or not. exitflag = 1.0 indicates “skip out event” has occured. exitflag = 0.0 indicates no “event” was detected in the trajectory, consider increasing simulation time. exitflag = -1.0 indicates “trap in event” has occured.

Parameters:

r (numpy.ndarray) – dimensional radial distance solution, meters

Returns:

  • index (int) – array index of the event location if one was detected, terminal index otherwise

  • exitflag (int) – flag to indicate and classify event occurence or lack of it

cogammabar(rbar, phi, vbar, psi, gamma)

Function to return non dimensional Coriolis acceleration term cogammabar

Parameters:

  • rbar (float) – non-dimensional radial position

  • phi (float) – latitude, radians

  • vbar (float) – non-dimensional planet-relative speed, m/s

  • psi (float) – heading angle, rad

  • gamma (float) – flight-path angle, rad

Returns:

ans – non dimensional Coriolis acceleration cogammabar

Return type:

float

computeAccelerationDrag(tc, rc, thetac, phic, vc, index, delta)

This function computes the drag acceleration load (Earth G’s) over the entire trajectory from trajectory data returned by the solver.

Parameters:

  • tc (numpy.ndarray) – truncated time array, sec

  • rc (numpy.ndarray) – truncated radial distance array, m

  • thetac (numpy.ndarray) – truncated longitude array, rad

  • phic (numpy.ndarray) – trucnated latitude array, rad

  • vc (numpy.ndarray) – truncated speed array, m

  • index (int) – array index of detected event location / max index if no event detected

  • delta (float) – bank angle, rad

Returns:

acc_drag_g – drag acceleration load (Earth G’s) over the entire trajectory

Return type:

numpy.ndarray

computeAccelerationLoad(tc, rc, thetac, phic, vc, index, delta)

This function computes the acceleration load (Earth G’s) over the entire trajectory from trajectory data returned by the solver.

Parameters:

  • tc (numpy.ndarray) – truncated time array, sec

  • rc (numpy.ndarray) – truncated radial distance array, m

  • thetac (numpy.ndarray) – truncated longitude array, rad

  • phic (numpy.ndarray) – trucnated latitude array, rad

  • vc (numpy.ndarray) – truncated speed array, m

  • index (int) – array index of detected event location / max index if no event detected

  • delta (float) – bank angle, rad

Returns:

acc_net_g – acceleration load (Earth G’s) over the entire trajectory

Return type:

numpy.ndarray

computeAngMomScalar(terminal_r, terminal_v, terminal_g)

This function computes the specific angular momentum (orbital) of the vehicle at an instance given its current radial distance, speed, and flight-path angle.

Parameters:

  • terminal_r (float) – radial distance, meters

  • terminal_v (float) – speed, meters/sec

  • terminal_g (float) – flight-path angle, rad

Returns:

ans – specific angular momentum, SI units

Return type:

float

computeDynPres(r, v)

This function computes the dynamic pressure over the entire trajectory.

Parameters:

  • r (numpy.ndarray) – radial distance array, m

  • v (numpy.ndarray) – speed array, m/s

Returns:

ans – dynamic pressure, Pa

Return type:

numpy.ndarray

computeEccScalar(h, E)

This function computes the eccentricity of the orbit given its specific angular momentum, and total specific mechanical energy.

Parameters:

  • h (float) – specific angular momentum, SI units

  • E (float) – specifice energy, J/kg

Returns:

ans – eccentricity value

Return type:

float

computeEnergy(rc, vc)

This function computes the total specific mechanical energy of the vehicle over the entire trajectory.

Parameters:

  • rc (numpy.ndarray) – radial distance array, m

  • vc (numpy.ndarray) – speed array, m/s

Returns:

ans – specific energy, J/kg

Return type:

numpy.ndarray

computeEnergyScalar(r, v)

This function computes the total specific mechanical energy of the vehicle at an instance.

Parameters:

  • r (float) – radial distance, m

  • v (float) – speed array, m/s

Returns:

ans – specific energy, J/kg

Return type:

float

computeHeatingForMultipleRN(tc, rc, vc, rn_array)

This function computes the max. stag. pont heating rate and heat load for an array of nose radii.

Parameters:

  • tc (numpy.ndarray) – truncated time array, sec

  • rc (numpy.ndarray) – truncated radial distance array, m

  • vc (numpy.ndarray) – speed array, m/s

  • rn_array (numpy.ndarray) – nose radius array, m

Returns:

  • q_stag_max (numpy.ndarray) – max. heat rate, W/cm2

  • heatload (numpy.ndarray) – max. heatload, J/cm2

computeMach(rc, vc)

This function computes the Mach. no over the entire trajectory.

Parameters:

  • rc (numpy.ndarray) – radial distance array, m

  • vc (numpy.ndarray) – speed array, m/s

Returns:

ans – Mach no.

Return type:

numpy.ndarray

computeMachScalar(r, v)

This function computes the Mach. no at a single instance.

Parameters:

  • r (float) – radial distance, m

  • v (floar) – speed, m/s

Returns:

ans – Mach no.

Return type:

float

computeSemiMajorAxisScalar(E)

This function computes the semi-major axis of the orbit given its total specific mechanical energy.

Parameters:

E (float) – specific energy, J/kg

Returns:

ans – semi major axis, km

Return type:

float

computeStagPres(rc, vc)

This function computes the stag. pressure over the entire trajectory.

Parameters:

  • rc (numpy.ndarray) – radial distance array, m

  • vc (numpy.ndarray) – speed array, m/s

Returns:

ans – stag. pressure, Pa

Return type:

numpy.ndarray

computeStagTemp(rc, vc)

This function computes the stag. temperature over the entire trajectory.

Parameters:

  • rc (numpy.ndarray) – radial distance array, m

  • vc (numpy.ndarray) – speed array, m/s

Returns:

ans – stag. temperature, K

Return type:

numpy.ndarray

computeTCW(t_sec, dt, gamma0_deg_guess_low_os, gamma0_deg_guess_high_os, gamma0_deg_guess_low_us, gamma0_deg_guess_high_us, gamma_deg_tol_os, gamma_deg_tol_us, targetApopasisAltitude_km)

Computes the theoretical corridor width (TCW) for lift modulation aerocapture.

TCW = overShootLimit - underShootLimit

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low_os (float) – lower bound for the guess of overshoot limit FPA, deg

  • gamma0_deg_guess_high_os (float) – upper bound for the guess of overshoot limit FPA, deg

  • gamma0_deg_guess_low_us (float) – lower bound for the guess of undershoot limit FPA, deg

  • gamma0_deg_guess_high_us (float) – upper bound for the guess of undershoot limit FPA, deg

  • gamma_deg_tol_os (float) – desired accuracy for computation of the overshoot limit, deg

  • gamma_deg_tol_us (float) – desired accuracy for computation of the undershoot limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

TCW – Theoretical Corridor Width, deg

Return type:

float

computeTCW2(t_sec, dt, gamma0_deg_guess_low_os, gamma0_deg_guess_high_os, gamma0_deg_guess_low_us, gamma0_deg_guess_high_us, gamma_deg_tol_os, gamma_deg_tol_us, targetApopasisAltitude_km)

Computes the theoretical corridor width (TCW) for lift modulation aerocapture. Includes effect of planet rotation.

TCW = overShootLimit - underShootLimit

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low_os (float) – lower bound for the guess of overshoot limit FPA, deg

  • gamma0_deg_guess_high_os (float) – upper bound for the guess of overshoot limit FPA, deg

  • gamma0_deg_guess_low_us (float) – lower bound for the guess of undershoot limit FPA, deg

  • gamma0_deg_guess_high_us (float) – upper bound for the guess of undershoot limit FPA, deg

  • gamma_deg_tol_os (float) – desired accuracy for computation of the overshoot limit, deg

  • gamma_deg_tol_us (float) – desired accuracy for computation of the undershoot limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

TCW – Theoretical Corridor Width, deg

Return type:

float

computeTCWD(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

Computes the theoretical corridor width (TCWD) for drag modulation aerocapture. Does not include planet rotation.

TCWD = overShootLimit - underShootLimit

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the EFPA guess, deg

  • gamma0_deg_guess_high (float) – upper bound for the EFPA guess, deg

  • gamma_deg_tol (float) – EFPA error tolerance

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

TCWD – Theoretical Corridor Width (Drag Modulation), deg

Return type:

float

computeTCWD2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

Computes the theoretical corridor width (TCWD) for drag modulation aerocapture. Includes planet rotation.

TCWD = overShootLimit - underShootLimit

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the EFPA guess, deg

  • gamma0_deg_guess_high (float) – upper bound for the EFPA guess, deg

  • gamma_deg_tol (float) – EFPA error tolerance

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

TCWD – Theoretical Corridor Width (Drag Modulation), deg

Return type:

float

compute_ApoapsisAltitudeKm(terminal_r, terminal_v, terminal_g, terminal_theta, terminal_phi, terminal_psi)

Compute the apoapsis altitude given conditions at atmospheric exit interface. Note this function includes correction to account for rotation of planet.

Terminal values refer to those at atmospheric exit.

Parameters:

  • terminal_r (float) – radial distance, m

  • terminal_v (float) – terminal speed, m/s

  • terminal_g (float) – terminal FPA, rad

  • terminal_theta (float) – terminal longitude, rad

  • terminal_phi (float) – terminal latitude, rad

  • terminal_psi (float) – terminal heading angle

Returns:

hp_km – apoapsis altitude, km

Return type:

float

compute_PeriapsisAltitudeKm(terminal_r, terminal_v, terminal_g, terminal_theta, terminal_phi, terminal_psi)

Compute the periapsis altitude given conditions at atmospheric exit interface. Note this function includes correction to account for rotation of planet.

Terminal values refer to those at atmospheric exit.

Parameters:

  • terminal_r (float) – radial distance, m

  • terminal_v (float) – terminal speed, m/s

  • terminal_g (float) – terminal FPA, rad

  • terminal_theta (float) – terminal longitude, rad

  • terminal_phi (float) – terminal latitude, rad

  • terminal_psi (float) – terminal heading angle

Returns:

hp_km – periapsis altitude, km

Return type:

float

compute_apoapsis_raise_DV(peri_km_current, apo_km_current, apo_km_target)

Compute the propulsive DV to raise the orbit apoapsis to the target value.

Parameters:

  • peri_km_current (float) – current periapsis altitude, km

  • apo_km_current (float) – current apoapsis altitude, km

  • apo_km_target (float) – target apoapsis altitude, km

Returns:

dV – apoapsis raise DV, m/s

Return type:

float

compute_periapsis_raise_DV(current_peri_km, current_apo_km, target_peri_km)

Compute the propulsive DV to raise the orbit periapsis to the target value.

Parameters:

  • current_peri_km (float) – current periapsis altitude, km

  • current_apo_km (float) – current apoapsis altitude, km

  • target_peri_km (float) – target periapsis altitude, km

Returns:

dV – periapse raise DV, m/s

Return type:

float

convertToKPa(pres)

Convert a pressure solution array from Pa to kPa.

Parameters:

pres (numpy.ndarray) – pressure (static/dynamic/total), Pascal (Pa)

Returns:

ans – pressure (static/dynamic/total), kiloPascal (kPa)

Return type:

numpy.ndarray

convertToPerCm2(heatrate)

Convert a heat rate from W/m2 to W/cm2.

Parameters:

heatrate (numpy.ndarray) – stagnation-point heat rate, W/m2

Returns:

ans – stagnation-point heat rate, W/cm2

Return type:

numpy.ndarray

convertToPlotUnits(t, r, v, phi, psi, theta, gamma, drange)

Convert state vector components to units appropriate for evolution plots.

Parameters:

  • t (numpy.ndarray) – time array, sec

  • r (numpy.ndarray) – radial distance array, m

  • v (numpy.ndarray) – speed array, m

  • phi (numpy.ndarray) – latitude array, rad

  • psi (numpy.ndarray) – heading angle array, rad

  • theta (numpy.ndarray) – longitude array, rad

  • gamma (numpy.ndarray) – flight path angle array, rad

  • drange (numpy.ndarray) – downrange array, meters

Returns:

  • t_min (numpy.ndarray) – time array, minutes

  • h_km (numpy.ndarray) – altitude array, km

  • v_kms (numpy.ndarray) – speed array, km/s

  • phi_deg (numpy.ndarray) – latitude array, deg

  • psi_deg (numpy.ndarray) – heading angle array, deg

  • theta_deg (numpy.ndarray) – longitude array, deg

  • gamma_deg (numpy.ndarray) – flight path angle array, deg

  • drange_km (numpy.ndarray) – downrange array, km

copsibar(rbar, phi, vbar, psi, gamma)

Function to return non dimensional Coriolis acceleration term copsibar

Parameters:

  • rbar (float) – non-dimensional radial position

  • phi (float) – latitude, radians

  • vbar (float) – non-dimensional planet-relative speed, m/s

  • psi (float) – heading angle, rad

  • gamma (float) – flight-path angle, rad

Returns:

ans – non dimensional Coriolis acceleration copsibar

Return type:

float

createDensityMeasuredFunction(h_step_array, density_mes_array, lowAlt_km, numPoints_lowAlt)

Computes a density function based on measurements made during the descending leg of the aerocapture maneuver.

Parameters:

  • h_step_array (numpy.ndarray) – height array at which density is measured, km

  • density_mes_array (numpy.ndarray) – density array corresponding to h_step_array, kg/m3

  • lowAlt_km (float) – lower altitude to which density model is to be extrapolated based on available measurements, km

  • numPoints_lowAlt (int) – number of points to evaluate extrapolation at below the altitude where measurements are available.

Returns:

  • density_mes_int (scipy.interpolate.interpolate.interp1d) – interpolated measured density lookup function

  • minAlt (float) – minimum altitude at which density measurements were available

createQPlot(t_sec, dt, delta_deg)

Creates q-plots as described by Cerimele and Gamble, 1985.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. solver time step

  • delta_deg (float) – commanded bank angle, degrees

Return type:

plt.plot object

dummyVehicle(density_mes_int)

Create a copy of the vehicle object which uses a measured density profile for propogation.

Parameters:

density_mes_int (scipy.interpolate.interpolate.interp1d) – density interpolation function

Returns:

vehicleCopy – dummy vehicle object

Return type:

vehicle object

findEFPALimitD(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

This function computes the limiting EFPA for drag modulation aerocapture. Does not include planetary rotation correction.

A bisection algorithm is used to compute the limit.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg

  • gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg

  • gamma_deg_tol (float) – desired accuracy for computation of the limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

  • EFPALimit (float) – limit EFPA, deg

  • exitflag (float) – flag to indicate if a solution could not be found for the limit EFPA

  • exitflag = 1.0 indicates over shoot limit was found.

  • exitflag = 0.0 indicates overshoot limit was not found

  • within user specified bounds.

findEFPALimitD2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

This function computes the limiting EFPA for drag modulation aerocapture. Includes planetary rotation correction. Includes planet rotation.

A bisection algorithm is used to compute the limit.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg

  • gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg

  • gamma_deg_tol (float) – desired accuracy for computation of the limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

  • EFPALimit (float) – limit EFPA, deg

  • exitflag (float) – flag to indicate if a solution could not be found for the limit EFPA

  • exitflag = 1.0 indicates over shoot limit was found.

  • exitflag = 0.0 indicates overshoot limit was not found

  • within user specified bounds.

findOverShootLimit(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

Computes the overshoot limit entry flight-path angle for aerocapture vehicle using bisection algorithm.

This is shallowest entry flight path angle for which a full lift down trajectory gets the vehicle captured into a post atmospheric exit orbit with the desired target apoapsis altitude.

Note: the overshoot limit entry flight path angle should be computed with an accuracy of at least 10 decimal places to ensure the correct atmospheric trajectory is simulated.

A bisection algorithm is used to compute the overshoot limit.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the guess of overshoot limit FPA, deg

  • gamma0_deg_guess_high (float) – upper bound for the guess of overshoot limit FPA, deg

  • gamma_deg_tol (float) – desired accuracy for computation of the overshoot limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

  • overShootLimit (float) – overshoot limit EFPA, deg

  • exitflag_os (float) – flag to indicate if a solution could not be found for the overshoot limit

  • exitflag_os = 1.0 indicates over shoot limit was found.

  • exitflag_os = 0.0 indicates overshoot limit was not found

  • within user specified bounds.

findOverShootLimit2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

Computes the overshoot limit entry flight-path angle for aerocapture vehicle using bisection algorithm. Includes effect of planet rotation on inertial speed.

This is shallowest entry flight path angle for which a full lift down trajectory gets the vehicle captured into a post atmospheric exit orbit with the desired target apoapsis altitude.

Note: the overshoot limit entry flight path angle should be computed with an accuracy of at least 10 decimal places to ensure the correct atmospheric trajectory is simulated.

A bisection algorithm is used to compute the overshoot limit.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the guess of overshoot limit FPA, deg

  • gamma0_deg_guess_high (float) – upper bound for the guess of overshoot limit FPA, deg

  • gamma_deg_tol (float) – desired accuracy for computation of the overshoot limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

  • overShootLimit (float) – overshoot limit EFPA, deg

  • exitflag_os (float) – flag to indicate if a solution could not be found for the overshoot limit

  • exitflag_os = 1.0 indicates over shoot limit was found.

  • exitflag_os = 0.0 indicates overshoot limit was not found

  • within user specified bounds.

findOverShootLimitD(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

This function computes the limiting overshoot EFPA for drag modulation aerocapture. Does not include planet rotation.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg

  • gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg

  • gamma_deg_tol (float) – desired accuracy for computation of the limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

  • overShootLimitD (float) – overshoot limit EFPA, deg

  • exitflagD_os (float) – flag to indicate if a solution could not be found for the overshoot limit EFPA

  • exitflagD_os = 1.0 indicates over shoot limit was found.

  • exitflagD_os = 0.0 indicates overshoot limit was not found

  • within user specified bounds.

findOverShootLimitD2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

This function computes the limiting overshoot EFPA for drag modulation aerocapture. Includes planet rotation.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg

  • gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg

  • gamma_deg_tol (float) – desired accuracy for computation of the limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

  • overShootLimitD (float) – overshoot limit EFPA, deg

  • exitflagD_os (float) – flag to indicate if a solution could not be found for the overshoot limit EFPA

  • exitflagD_os = 1.0 indicates over shoot limit was found.

  • exitflagD_os = 0.0 indicates overshoot limit was not found

  • within user specified bounds.

findUnderShootLimit(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

Computes the undershoot limit entry flight-path angle for aerocapture vehicle using bisection algorithm.

This is steepest entry flight path angle for which a full lift up trajectory gets the vehicle captured into a post atmospheric exit orbit with the desired target apoapsis altitude.

Note: the undershoor limit entry flight path angle should be computed with an accuracy of at least 6 decimal places to ensure the correct atmospheric trajectory is simulated.

A bisection algorithm is used to compute the undershoot limit.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the guess of overshoot limit FPA, deg

  • gamma0_deg_guess_high (float) – upper bound for the guess of overshoot limit FPA, deg

  • gamma_deg_tol (float) – desired accuracy for computation of the overshoot limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

  • underShootLimit (float) – overshoot limit EFPA, deg

  • exitflag_us (float) – flag to indicate if a solution could not be found for the undershoot limit

  • exitflag_us = 1.0 indicates undershoot limit was found.

  • exitflag_us = 0.0 indicates overshoot limit was not found

  • within user specified bounds.

findUnderShootLimit2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

Computes the undershoot limit entry flight-path angle for aerocapture vehicle using bisection algorithm. Includes effect of planet rotation on inertial speed.

This is steepest entry flight path angle for which a full lift up trajectory gets the vehicle captured into a post atmospheric exit orbit with the desired target apoapsis altitude.

Note: the undershoor limit entry flight path angle should be computed with an accuracy of at least 6 decimal places to ensure the correct atmospheric trajectory is simulated.

A bisection algorithm is used to compute the undershoot limit.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the guess of overshoot limit FPA, deg

  • gamma0_deg_guess_high (float) – upper bound for the guess of overshoot limit FPA, deg

  • gamma_deg_tol (float) – desired accuracy for computation of the overshoot limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

  • underShootLimit (float) – overshoot limit EFPA, deg

  • exitflag_us (float) – flag to indicate if a solution could not be found for the undershoot limit

  • exitflag_us = 1.0 indicates undershoot limit was found.

  • exitflag_us = 0.0 indicates overshoot limit was not found

  • within user specified bounds.

findUnderShootLimitD(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

This function computes the limiting undershoot EFPA for drag modulation aerocapture. Does not include planet rotation.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg

  • gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg

  • gamma_deg_tol (float) – desired accuracy for computation of the limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

  • underShootLimitD (float) – undershoot limit EFPA, deg

  • exitflagD_us (float) – flag to indicate if a solution could not be found for the undershoot limit EFPA

  • exitflagD_us = 1.0 indicates undershoot limit was found.

  • exitflagD_us = 0.0 indicates undershoot limit was not found

  • within user specified bounds.

findUnderShootLimitD2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)

This function computes the limiting undershoot EFPA for drag modulation aerocapture. Includes planet rotation.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg

  • gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg

  • gamma_deg_tol (float) – desired accuracy for computation of the limit, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

  • underShootLimitD (float) – undershoot limit EFPA, deg

  • exitflagD_us (float) – flag to indicate if a solution could not be found for the undershoot limit EFPA

  • exitflagD_us = 1.0 indicates undershoot limit was found.

  • exitflagD_us = 0.0 indicates undershoot limit was not found

  • within user specified bounds.

gnbar(rbar, phi, gamma, psi)

Returns the non-dimensional gravity normal acceleration term gnbar.

Parameters:

  • rbar (float) – non-dimensional radial position

  • phi (float) – latitude, radians

  • gamma (float) – flight-path angle, rad

  • psi (float) – heading angle, rad

Returns:

ans – non-dimensional gravity normal acceleration term gnbar

Return type:

float

gphibar(rbar, phi)

Returns the non-dimensional gravity latitudinal acceleration term gphibar.

Parameters:

  • rbar (float) – non-dimensional radial position

  • phi (float) – latitude, radians

Returns:

ans – non-dimensional gravity latitudinal acceleration term gphibar

Return type:

float

grbar(rbar, phi)

Returns the non-dimensional gravity radial acceleration term grbar.

grbar is the non dimensional gravity radial acceleration term grbar in the EOM

Parameters:

  • rbar (float) – non-dimensional radial position

  • phi (float) – latitude, radians

Returns:

ans – non-dimensional radial acceleration term grbar

Return type:

float

gsbar(rbar, phi, gamma, psi)

Returns the non-dimensional gravity tangential acceleration term gsbar.

Parameters:

  • rbar (float) – non-dimensional radial position

  • phi (float) – latitude, radians

  • gamma (float) – flight-path angle, rad

  • psi (float) – heading angle, rad

Returns:

ans – non-dimensional gravity tangential acceleration term gsbar

Return type:

float

gthetabar(rbar, phi)

Returns the non-dimensional gravity longitudinal acceleration term.

gthetabar is the non dimensional longitudinal gravity acceleration term grbar in the EOM

Parameters:

  • rbar (float) – non-dimensional radial position

  • phi (float) – latitude, radians

Returns:

ans – non-dimensional longitudinal gravity acceleration term gthetabar

Return type:

float

gwbar(rbar, phi, gamma, psi)

Returns the non-dimensional gravity binormal acceleration term gwbar.

Parameters:

  • rbar (float) – non-dimensional radial position

  • phi (float) – latitude, radians

  • gamma (float) – flight-path angle, rad

  • psi (float) – heading angle, rad

Returns:

ans – non-dimensional gravity binormal acceleration term gwbar

Return type:

float

hitsTargetApoapsis(t_sec, dt, delta_deg, targetApopasisAltitude_km)

This function is used to check if the vehicle undershoots or overshoots. Does not include effect of planet rotation to compute inertial speed.

Returns +1 if the vehicle is captured into an orbit with the required target apoapsis alt, -1 otherwise.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • delta_deg (float) – bank angle command, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

ans – -1 indicates overshoot, +1 indicates undershoot

Return type:

int

hitsTargetApoapsis2(t_sec, dt, delta_deg, targetApopasisAltitude_km)

This function is used to check if the vehicle undershoots or overshoots. Includes effect of planet rotation to calculate inertial speed.

Returns +1 if the vehicle is captured into an orbit with the required target apoapsis alt, -1 otherwise.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • delta_deg (float) – bank angle command, deg

  • targetApopasisAltitude_km (float) – target apoapsis altitude , km

Returns:

ans – -1 indicates overshoot, +1 indicates undershoot

Return type:

int

isCaptured(t_sec, dt, delta_deg)

This function determines if the vehicle is captured. Returns -1 if the vehicle is captured, +1 otherwise.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • delta_deg (float) – bank angle command, deg

Returns:

ans

Return type:

int

makeBasicEntryPlots()

This function creates the evolution plots of the altitude, speed, deceleration, and heat rate

Parameters:

None. –

Return type:

1 image with 4 subplots

predictApoapsisAltitudeKm_afterJettision(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)

Compute the apoapsis altitude at exit if the drag skirt is jettisoned at the current vehicle state.

Parameters:

  • h0_km (float) – current vehicle altitude, km

  • theta0_deg (float) – current vehicle longitude, deg

  • phi0_deg (float) – current vehicle latitude, deg

  • v0_kms (float) – current vehicle speed, km/s

  • gamma0_deg (float) – current FPA, deg

  • psi0_deg (float) – current heading angle, deg

  • drange0_km (float) – current downrange, km

  • heatLoad0 (float) – current heatload, J/cm2

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. solver timestep

  • delta_deg (float) – commanded bank angle, deg

  • density_mes_int (scipy.interpolate.interpolate.interp1d) – measured density interpolation function

Returns:

terminal_apoapsis_km – apoapsis altitude achieved if drag skirt is jettisoned at the current time, km

Return type:

float

predictApoapsisAltitudeKm_afterJettision2(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)

Compute the apoapsis altitude at exit if the drag skirt is jettisoned at the current vehicle state. Uses new solver.

Parameters:

  • h0_km (float) – current vehicle altitude, km

  • theta0_deg (float) – current vehicle longitude, deg

  • phi0_deg (float) – current vehicle latitude, deg

  • v0_kms (float) – current vehicle speed, km/s

  • gamma0_deg (float) – current FPA, deg

  • psi0_deg (float) – current heading angle, deg

  • drange0_km (float) – current downrange, km

  • heatLoad0 (float) – current heatload, J/cm2

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. solver timestep

  • delta_deg (float) – commanded bank angle, deg

  • density_mes_int (scipy.interpolate.interpolate.interp1d) – measured density interpolation function

Returns:

terminal_apoapsis_km – apoapsis altitude achieved if drag skirt is jettisoned at the current time, km

Return type:

float

predictApoapsisAltitudeKm_withLiftUp(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)

Compute apoapsis altitude using full lift up bank command from current vehicle state till atmospheric exit.

Parameters:

  • h0_km (float) – current vehicle altitude, km

  • theta0_deg (float) – current vehicle longitude, deg

  • phi0_deg (float) – current vehicle latitude, deg

  • v0_kms (float) – current vehicle speed, km/s

  • gamma0_deg (float) – current FPA, deg

  • psi0_deg (float) – current heading angle, deg

  • drange0_km (float) – current downrange, km

  • heatLoad0 (float) – current heatload, J/cm2

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. solver timestep

  • delta_deg (float) – commanded bank angle, deg

  • density_mes_int (scipy.interpolate.interpolate.interp1d) – measured density interpolation function

predictApoapsisAltitudeKm_withLiftUp2(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)

Compute apoapsis altitude using full lift up bank command from current vehicle state till atmospheric exit.

Parameters:

  • h0_km (float) – current vehicle altitude, km

  • theta0_deg (float) – current vehicle longitude, deg

  • phi0_deg (float) – current vehicle latitude, deg

  • v0_kms (float) – current vehicle speed, km/s

  • gamma0_deg (float) – current FPA, deg

  • psi0_deg (float) – current heading angle, deg

  • drange0_km (float) – current downrange, km

  • heatLoad0 (float) – current heatload, J/cm2

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. solver timestep

  • delta_deg (float) – commanded bank angle, deg

  • density_mes_int (scipy.interpolate.interpolate.interp1d) – measured density interpolation function

propogateEntry(t_sec, dt, delta_deg)

Propogates the vehicle state for a specified time using initial conditions, vehicle properties, and atmospheric profile data.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • delta_deg (float) – bank angle command, deg

propogateEntry2(t_sec, dt, delta_deg)

Propogates the vehicle state for a specified time using initial conditions, vehicle properties, and atmospheric profile data.

Parameters:

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • delta_deg (float) – bank angle command, deg

propogateEntryPhaseD(timeStep, dt, maxTimeSecs)

Implements the entry phase of the guided drag modulation aerocapture (Single-event discrete drag modulation).

The entry phase is defined from the atmospheric entry interface till drag skirt jettison.

Parameters:

  • timeStep (float) – Guidance cycle time, seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

propogateEntryPhaseD2(timeStep, dt, maxTimeSecs)

Implements the entry phase of the guided drag modulation aerocapture (Single-event discrete drag modulation).

The entry phase is defined from the atmospheric entry interface till drag skirt jettison.

Parameters:

  • timeStep (float) – Guidance cycle time, seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

propogateEntry_util(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)

Utility propogator routine for prediction of atmospheric exit conditions which is then supplied to the apoapis prediction module.

Propogates the vehicle state for using the measured atmospheric profile during the descending leg.

Parameters:

  • h0_km (float) – current altitude, km

  • theta0_deg (float) – current longitude, deg

  • phi0_deg (float) – current latitude, deg

  • v0_kms (float) – current speed, km/s

  • gamma0_deg (float) – current FPA, deg

  • psi0_deg (float) – current heading angle, deg

  • drange0_km (float) – current downrange, km

  • heatLoad0 (float) – current heatload, J/cm2

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • delta_deg (float) – bank angle command, deg

Returns:

  • t_minc (numpy.ndarray) – time solution array, min

  • h_kmc (numpy.ndarray) – altitude solution array, km

  • v_kmsc (numpy.ndarray) – speed solution array, km/s

  • phi_degc (numpy.ndarray) – latitude solution array, deg

  • psi_degc (numpy.ndarray) – heading angle solution array, deg

  • theta_degc (numpy.ndarray) – longitude solution array, deg

  • gamma_degc (numpy.ndarray) – FPA solution array, deg

  • drange_kmc (numpy.ndarray) – downrange solution array, km

  • exitflag (int) – exitflag

  • acc_net_g (numpy.ndarray) – acceleration solution array, Earth g

  • dyn_pres_atm (numpy.ndarray) – dynamic pressure solution array, atm

  • stag_pres_atm (numpy.ndarray) – stagnation pressure array, atm

  • q_stag_total (numpy.ndarray) – stagnation point heat rate array

  • heatload (numpy.ndarray) – stagnation point heat load

  • acc_drag_g (numpy.ndarray) – acceleration due to drag, Earth g

propogateEntry_util2(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)

Utility propogator routine for prediction of atmospheric exit conditions which is then supplied to the apoapis prediction module.

Propogates the vehicle state for using the measured atmospheric profile during the descending leg.

Parameters:

  • h0_km (float) – current altitude, km

  • theta0_deg (float) – current longitude, deg

  • phi0_deg (float) – current latitude, deg

  • v0_kms (float) – current speed, km/s

  • gamma0_deg (float) – current FPA, deg

  • psi0_deg (float) – current heading angle, deg

  • drange0_km (float) – current downrange, km

  • heatLoad0 (float) – current heatload, J/cm2

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • delta_deg (float) – bank angle command, deg

Returns:

  • t_minc (numpy.ndarray) – time solution array, min

  • h_kmc (numpy.ndarray) – altitude solution array, km

  • v_kmsc (numpy.ndarray) – speed solution array, km/s

  • phi_degc (numpy.ndarray) – latitude solution array, deg

  • psi_degc (numpy.ndarray) – heading angle solution array, deg

  • theta_degc (numpy.ndarray) – longitude solution array, deg

  • gamma_degc (numpy.ndarray) – FPA solution array, deg

  • drange_kmc (numpy.ndarray) – downrange solution array, km

  • exitflag (int) – exitflag

  • acc_net_g (numpy.ndarray) – acceleration solution array, Earth g

  • dyn_pres_atm (numpy.ndarray) – dynamic pressure solution array, atm

  • stag_pres_atm (numpy.ndarray) – stagnation pressure array, atm

  • q_stag_total (numpy.ndarray) – stagnation point heat rate array

  • heatload (numpy.ndarray) – stagnation point heat load

  • acc_drag_g (numpy.ndarray) – acceleration due to drag, Earth g

propogateEntry_utilD(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)

Utility propogator routine for prediction of atmospheric exit conditions which is then supplied to the apoapis prediction module. Does not include planetary rotation.

Propogates the vehicle state for using the measured atmospheric profile during the descending leg.

Parameters:

  • h0_km (float) – current altitude, km

  • theta0_deg (float) – current longitude, deg

  • phi0_deg (float) – current latitude, deg

  • v0_kms (float) – current speed, km/s

  • gamma0_deg (float) – current FPA, deg

  • psi0_deg (float) – current heading angle, deg

  • drange0_km (float) – current downrange, km

  • heatLoad0 (float) – current heatload, J/cm2

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • delta_deg (float) – bank angle command, deg

Returns:

  • t_minc (numpy.ndarray) – time solution array, min

  • h_kmc (numpy.ndarray) – altitude solution array, km

  • v_kmsc (numpy.ndarray) – speed solution array, km/s

  • phi_degc (numpy.ndarray) – latitude solution array, deg

  • psi_degc (numpy.ndarray) – heading angle solution array, deg

  • theta_degc (numpy.ndarray) – longitude solution array, deg

  • gamma_degc (numpy.ndarray) – FPA solution array, deg

  • drange_kmc (numpy.ndarray) – downrange solution array, km

  • exitflag (int) – exitflag

  • acc_net_g (numpy.ndarray) – acceleration solution array, Earth g

  • dyn_pres_atm (numpy.ndarray) – dynamic pressure solution array, atm

  • stag_pres_atm (numpy.ndarray) – stagnation pressure array, atm

  • q_stag_total (numpy.ndarray) – stagnation point heat rate array

  • heatload (numpy.ndarray) – stagnation point heat load

  • acc_drag_g (numpy.ndarray) – acceleration due to drag, Earth g

propogateEntry_utilD2(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)

Utility propogator routine for prediction of atmospheric exit conditions which is then supplied to the apoapis prediction module. Includes planetary rotation.

Propogates the vehicle state for using the measured atmospheric profile during the descending leg.

Parameters:

  • h0_km (float) – current altitude, km

  • theta0_deg (float) – current longitude, deg

  • phi0_deg (float) – current latitude, deg

  • v0_kms (float) – current speed, km/s

  • gamma0_deg (float) – current FPA, deg

  • psi0_deg (float) – current heading angle, deg

  • drange0_km (float) – current downrange, km

  • heatLoad0 (float) – current heatload, J/cm2

  • t_sec (float) – propogation time, seconds

  • dt (float) – max. time step, seconds

  • delta_deg (float) – bank angle command, deg

Returns:

  • t_minc (numpy.ndarray) – time solution array, min

  • h_kmc (numpy.ndarray) – altitude solution array, km

  • v_kmsc (numpy.ndarray) – speed solution array, km/s

  • phi_degc (numpy.ndarray) – latitude solution array, deg

  • psi_degc (numpy.ndarray) – heading angle solution array, deg

  • theta_degc (numpy.ndarray) – longitude solution array, deg

  • gamma_degc (numpy.ndarray) – FPA solution array, deg

  • drange_kmc (numpy.ndarray) – downrange solution array, km

  • exitflag (int) – exitflag

  • acc_net_g (numpy.ndarray) – acceleration solution array, Earth g

  • dyn_pres_atm (numpy.ndarray) – dynamic pressure solution array, atm

  • stag_pres_atm (numpy.ndarray) – stagnation pressure array, atm

  • q_stag_total (numpy.ndarray) – stagnation point heat rate array

  • heatload (numpy.ndarray) – stagnation point heat load

  • acc_drag_g (numpy.ndarray) – acceleration due to drag, Earth g

propogateEquilibriumGlide(timeStep, dt, maxTimeSecs)

Implements the equilibrium glide phase of the guidance scheme.

Parameters:

  • timeStep (float) – Guidance cycle time, seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

propogateEquilibriumGlide2(timeStep, dt, maxTimeSecs)

Implements the equilibrium glide phase of the guidance scheme.

Parameters:

  • timeStep (float) – Guidance cycle time, seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

propogateExitPhase(timeStep, dt, maxTimeSecs)

Implements the exit phase of the guidance scheme (full lift-up).

Parameters:

  • timeStep (float) – Guidance cycle time, seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

propogateExitPhase2(timeStep, dt, maxTimeSecs)

Implements the exit phase of the guidance scheme (full lift-up).

Parameters:

  • timeStep (float) – Guidance cycle time, seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

propogateExitPhaseD(timeStep, dt, maxTimeSecs)

Implements the exit phase of the guidance scheme for drag modulation.

Parameters:

  • timeStep (float) – Guidance cycle time, seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

propogateExitPhaseD2(timeStep, dt, maxTimeSecs)

Implements the exit phase of the guidance scheme for drag modulation, with new solver.

Parameters:

  • timeStep (float) – Guidance cycle time, seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

propogateGuidedEntry(timeStep, dt, maxTimeSecs)

Implements the full guidance scheme (eq. glide + exit phase)

Parameters:

  • timeStep (float) – Guidance cycle time, seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

propogateGuidedEntry2(timeStep, dt, maxTimeSecs)

Implements the full guidance scheme (eq. glide + exit phase)

Parameters:

  • timeStep (float) – Guidance cycle time, seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

propogateGuidedEntryD(timeStepEntry, timeStepExit, dt, maxTimeSecs)

Implements the full guidance scheme for drag modulation aerocapture (entry phase + exit phase)

Parameters:

  • timeStepEntry (float) – Guidance cycle time (entry phase), seconds

  • timeStepExit (float) – Guidance cycle time (exit phase), seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

propogateGuidedEntryD2(timeStepEntry, timeStepExit, dt, maxTimeSecs)

Implements the full guidance scheme for drag modulation aerocapture (entry phase + exit phase). Includes inertial correction.

Parameters:

  • timeStepEntry (float) – Guidance cycle time (entry phase), seconds

  • timeStepExit (float) – Guidance cycle time (exit phase), seconds

  • dt (float) – Solver max. time step, seconds

  • maxTimeSecs (float) – max. time for propogation, seconds

psuedoController(DeltaCMD_deg_command, Delta_deg_ini, timestep)

Pseudo controller implenetation for maximum roll rate constraint.

Parameters:

  • DeltaCMD_deg_command (float) – commanded bank angle from guidance algorithm, deg

  • Delta_deg_ini (float) – current vehicle bank angle, deg

  • maxBankRate (float) – maximum allowed roll rate, deg/s

  • timestep (float) – guidance cycle timestep

Returns:

  • DeltaCMD_deg (float) – actual bank angle response using pseudocontroller, deg

  • Delta_deg_ini (float) – current bank angle, same as actual bank angle (is redundant)

qStagConvective(r, v)

This function defines the convective stagnation-point heating relationships. Edit the parameters in the source-code if you wish to modify these values.

Sources : Sutton-Graves relationships, NASA Neptune Orbiter with Probes Vision Report, Bienstock et al.

Parameters:

  • r (numpy.ndarray) – radial distance solution array of trajectory, m

  • v (numpy.ndarray) – planet-relative speed array of trajectory, m/s

Returns:

ans – convective stagnation-point heating rate array, W/cm2

Return type:

numpy.ndarray

qStagRadiative(r, v)

This function defines the radiative stagnation-point heating relationships. Edit the parameters in the source-code if you wish to modify these values.

Radiative heating is currently set to 0 for Mars and Titan, though these may not be negligible under certain conditions.

Sources :

Craig and Lyne, 2005; Brandis and Johnston, 2014; NASA Vision Neptune orbiter with probes, Contract No. NNH04CC41C

Parameters:

  • r (numpy.ndarray) – radial distance solution array of trajectory, m

  • v (numpy.ndarray) – planet-relative speed array of trajectory, m/s

Returns:

ans – radiative stagnation-point heating rate array, W/cm2

Return type:

numpy.ndarray

qStagTotal(r, v)

Computes the total heat rate which is the sum of the convective and radiative heating rates.

Parameters:

  • r (numpy.ndarray) – radial distance solution array of trajectory, m

  • v (numpy.ndarray) – planet-relative speed array of trajectory, m/s

Returns:

ans – total stagnation-point heating rate array, W/cm2

Return type:

numpy.ndarray

runMonteCarlo(N, mainFolder)

Run a Monte Carlo simulation for lift modulation aerocapture.

Parameters:

  • N (int) – Number of trajectories

  • mainFolder (str) – path where data is to be stored

runMonteCarlo2(N, mainFolder)

Run a Monte Carlo simulation for lift modulation aerocapture.

Parameters:

  • N (int) – Number of trajectories

  • mainFolder (str) – path where data is to be stored

runMonteCarloD(N, mainFolder)

Run a Monte Carlo simulation for drag modulation aerocapture.

Parameters:

  • N (int) – Number of trajectories

  • mainFolder (str) – path where data is to be stored

runMonteCarloD2(N, mainFolder)

Run a Monte Carlo simulation for drag modulation aerocapture with new solver.

Parameters:

  • N (int) – Number of trajectories

  • mainFolder (str) – path where data is to be stored

runMonteCarloD_Earth(N, mainFolder)

Run a Monte Carlo simulation for drag modulation aerocapture. (Earth application)

Parameters:

  • N (int) – Number of trajectories

  • mainFolder (str) – path where data is to be stored

setCDMachFunction(func)

Set function for CD (Mach)

Parameters:

func (function object) – vectorized numpy function which returns CD (Mach) Note: func must return scalar for scalar input, and array for array input!

setDragEntryPhaseParams(v_switch_kms, lowAlt_km, numPoints_lowAlt, hdot_threshold)

Set entry phase guidance parameters for drag modulation

Parameters:

  • v_switch_kms (float) – speed below which entry phase is terminated

  • lowAlt_km (float) – lower altitude to which density model is to be extrapolated based on available measurements, km

  • numPoints_lowAlt (int) – number of points to evaluate extrapolation at below the altitude where measurements are available

  • hdot_threshold (float) – threshold altitude rate (m/s) above which density measurement is terminated and apoapsis prediction is initiated

setDragModulationVehicleParams(beta1, betaRatio)

Set the beta1 and betaRatio params for a drag modulation vehicle.

Parameters:

  • beta1 (float) – small value of ballistic coefficient, kg/m2

  • betaRatio (float) – ballistic coefficient ratio

setEquilibriumGlideParams(Ghdot, Gq, v_switch_kms, lowAlt_km, numPoints_lowAlt, hdot_threshold)

Set equilibrium glide phase guidance parameters

Parameters:

  • Ghdot (float) – Ghdot term

  • Gq (float) – Gq term

  • v_switch_kms (float) – speed below which eq. glide phase is terminated

  • lowAlt_km (float) – lower altitude to which density model is to be extrapolated based on available measurements, km

  • numPoints_lowAlt (int) – number of points to evaluate extrapolation at below the altitude where measurements are available

  • hdot_threshold (float) – threshold altitude rate (m/s) above which density measurement is terminated and apoapsis prediction is initiated

setInitialState(h0_km, theta0_deg, phi0_deg, v0_kms, psi0_deg, gamma0_deg, drange0_km, heatLoad0)

Set initial vehicle state at atmospheric entry interface

Parameters:

  • h0_km (float) – initial vehicle altitude at atmospheric interface / other start point, meters

  • theta0_deg (float) – initial vehicle longitude at atmospheric interface / other start point, degrees

  • phi0_deg (float) – initial vehicle latitude at atmospheric interface / other start point, degrees

  • v0_kms (float) – initial vehicle speed (planet-relative) at atmospheric interface / other start point, km/s

  • psi0_deg (float) – initial vehicle heading at atmospheric interface / other start point, degrees

  • gamma0_deg (float) – initial vehicle flight-path angle at atmospheric interface / other start point, degrees

  • drange0_km (float) – initial vehicle downrange at atmospheric interface / other start point, km

  • heatLoad0 (float) – initial vehicle heatload at atmospheric interface / other start point, J/cm2

setMaxRollRate(maxRollRate)

Set the maximum allowed vehicle roll rate (deg/s)

Parameters:

maxRollRate (float) – maximum roll rate, degrees per second

setSolverParams(tol)

Set the solver parameters.

Parameters:

tol (float) – solver tolerance, currently both abstol and reltol are set to this value

setTargetOrbitParams(target_peri_km, target_apo_km, target_apo_km_tol)

Set the target capture orbit parameters.

Parameters:

  • target_peri_km (float) – target periapsis altitude, km

  • target_apo_km (float) – target apoapsis altitude, km

  • target_apo_km_tol (float) – target apoapsis altitude error tolerance, km used by guidance algorithm

setupMonteCarloSimulation(NPOS, NMONTE, atmfiles, heightCol, densLowCol, densAvgCol, densHighCol, densTotalCol, heightInKmFlag, nominalEFPA, EFPA_1sigma_value, nominalLD, LD_1sigma_value, timeStep, dt, maxTimeSecs, atmSigmaFactor=1)

Set the Monte Carlo simulation parameters.

Parameters:

  • NPOS (int) – NPOS value from GRAM model output is the number of data points (altitude) in each atm. profile

  • NMONTE (int) – NMONTE is the number of Monte Carlo atm profiles from GRAM model output

  • atmfiles (str) – location of atmospheric files used in Monte Carlo simulation

  • heightCol (int) – column index of height values in atmfiles

  • densLowCol (int) – column index of low density (-1 sigma) values in atmfiles

  • densAvgCol (int) – column index of average density values in atmfiles

  • densHighCol (int) – column index of high density values (+1 sigma) in atmfiles

  • densTotalCol (int) – index of perturbed (=avg + pert.) density values

  • heightInKmFlag (bool) – set to True if height values in atmfiles are in km

  • nominalEFPA (float) – Nominal (target EFPA) value, deg

  • EFPA_1sigma_value (float) – 1-sigma error for EFPA (from naviation analysis)

  • nominalLD (float) – Nominal value of vehicle L/D

  • LD_1sigma_value (float) – 1-sigma error for L/D (from vehicle aero. design data)

  • timeStep (float) – Guidance cycle time step, sec

  • dt (float) – max. solver time step

  • maxTimeSecs (float) – max. time used for propogation used by guidance scheme

setupMonteCarloSimulationD(NPOS, NMONTE, atmfiles, heightCol, densLowCol, densAvgCol, densHighCol, densTotalCol, heightInKmFlag, nominalEFPA, EFPA_1sigma_value, nominalbeta1, beta1_1sigma_value, timeStepEntry, timeStepExit, dt, maxTimeSecs)

Set the Monte Carlo simulation parameters for drag modulation aerocapture.

Parameters:

  • NPOS (int) – NPOS value from GRAM model output is the number of data points (altitude) in each atm. profile

  • NMONTE (int) – NMONTE is the number of Monte Carlo atm profiles from GRAM model output

  • atmfiles (str) – location of atmospheric files used in Monte Carlo simulation

  • heightCol (int) – column index of height values in atmfiles

  • densLowCol (int) – column index of low density (-1 sigma) values in atmfiles

  • densAvgCol (int) – column index of average density values in atmfiles

  • densHighCol (int) – column index of high density values (+1 sigma) in atmfiles

  • densTotalCol (int) – index of perturbed (=avg + pert.) density values

  • heightInKmFlag (bool) – set to True if height values in atmfiles are in km

  • nominalEFPA (float) – Nominal (target EFPA) value, deg

  • EFPA_1sigma_value (float) – 1-sigma error for EFPA (from naviation analysis)

  • nominalbeta1 (float) – Nominal value of vehicle ballistic coeff.

  • beta1_1sigma_value (float) – 1-sigma error for beta1 (from vehicle aero. design data)

  • timeStepEntry (float) – Guidance cycle time step for entry phase, sec

  • timeStepExit (float) – Guidance time step for exit phase, sec

  • dt (float) – max. solver time step

  • maxTimeSecs (float) – max. time used for propogation used by guidance scheme

setupMonteCarloSimulationD_Earth(NPOS, NMONTE, atmfiles, heightCol, densAvgCol, densSD_percCol, densTotalCol, heightInKmFlag, nominalEFPA, EFPA_1sigma_value, nominalbeta1, beta1_1sigma_value, timeStepEntry, timeStepExit, dt, maxTimeSecs)

Set the Monte Carlo simulation parameters for drag modulation aerocapture. (Earth aerocapture)

Parameters:

  • NPOS (int) – NPOS value from GRAM model output is the number of data points (altitude) in each atm. profile

  • NMONTE (int) – NMONTE is the number of Monte Carlo atm profiles from GRAM model output

  • atmfiles (str) – location of atmospheric files used in Monte Carlo simulation

  • heightCol (int) – column index of height values in atmfiles

  • densAvgCol (int) – column index of average density values in atmfiles

  • densSD_percCol (int) – column number of mean density one sigma SD

  • densTotalCol (int) – index of perturbed (=avg + pert.) density values

  • heightInKmFlag (bool) – set to True if height values in atmfiles are in km

  • nominalEFPA (float) – Nominal (target EFPA) value, deg

  • EFPA_1sigma_value (float) – 1-sigma error for EFPA (from naviation analysis)

  • nominalbeta1 (float) – Nominal value of vehicle ballistic coeff.

  • beta1_1sigma_value (float) – 1-sigma error for beta1 (from vehicle aero. design data)

  • timeStepEntry (float) – Guidance cycle time step for entry phase, sec

  • timeStepExit (float) – Guidance time step for exit phase, sec

  • dt (float) – max. solver time step

  • maxTimeSecs (float) – max. time used for propogation used by guidance scheme

solveTrajectory(rbar0, theta0, phi0, vbar0, psi0, gamma0, drangebar0, t_sec, dt, delta)

Function to propogate a single atmospheric entry trajectory given entry interface / other initial conditions and bank angle delta.

Reference 1: Vinh, Chapter 3. Reference 2: Lescynzki, MS Thesis, NPS.

Parameters:

  • rbar0 (float) – non-dimensional radial distance initial condition

  • theta0 (float) – longitude initial condition, rad

  • phi0 (float) – latatitude initial condition, rad

  • vbar0 (float) – non-dimensional planet-relative speed initial condition

  • psi0 (float) – heading angle initial condition, rad

  • gamma0 (float) – entry flight-path angle initial condition, rad

  • drangebar0 (float) – non-dimensional downrange initial condition

  • t_sec (float) – time in seconds for which propogation is done

  • dt (float) – max. time step size in seconds

  • delta (float) – bank angle command, rad

Returns:

  • tbar (numpy.ndarray) – nondimensional time at which solution is computed

  • rbar (numpy.ndarray) – nondimensional radial distance solution

  • theta (numpy.ndarray) – longitude solution, rad

  • phi (numpy.ndarray) – latitude array, rad

  • vbar (numpy.ndarray) – nondimensional velocity solution

  • psi (numpy.ndarray, rad) – heading angle solution, rad

  • gamma (numpy.ndarray) – flight-path angle, rad

  • drangebar (numpy.ndarray) – downrange solution, meters

solveTrajectory2(rbar0, theta0, phi0, vbar0, psi0, gamma0, drangebar0, t_sec, dt, delta)

Function to propogate a single atmospheric entry trajectory given entry interface / other initial conditions and bank angle delta.

Reference 1: Vinh, Chapter 3. Reference 2: Lescynzki, MS Thesis, NPS.

Parameters:

  • rbar0 (float) – non-dimensional radial distance initial condition

  • theta0 (float) – longitude initial condition, rad

  • phi0 (float) – latatitude initial condition, rad

  • vbar0 (float) – non-dimensional planet-relative speed initial condition

  • psi0 (float) – heading angle initial condition, rad

  • gamma0 (float) – entry flight-path angle initial condition, rad

  • drangebar0 (float) – non-dimensional downrange initial condition

  • t_sec (float) – time in seconds for which propogation is done

  • dt (float) – max. time step size in seconds

  • delta (float) – bank angle command, rad

Returns:

  • tbar (numpy.ndarray) – nondimensional time at which solution is computed

  • rbar (numpy.ndarray) – nondimensional radial distance solution

  • theta (numpy.ndarray) – longitude solution, rad

  • phi (numpy.ndarray) – latitude array, rad

  • vbar (numpy.ndarray) – nondimensional velocity solution

  • psi (numpy.ndarray, rad) – heading angle solution, rad

  • gamma (numpy.ndarray) – flight-path angle, rad

  • drangebar (numpy.ndarray) – downrange solution, meters

truncateTrajectory(t, r, theta, phi, v, psi, gamma, drange, index)

This function truncates the full trajectory returned by the solver to the first event location.

The full trajectory returned by the solver could have skipped out exceeding the skip out altitude, or could have descended below the trap in altitude or even below the surface.

This function helps ensure that we truncate the trajectory to what we actually need, i.e. till a skip out / trap in event.

Parameters:

  • t (numpy.ndarray) – time array, sec

  • r (numpy.ndarray) – radial distance array, m

  • v (numpy.ndarray) – speed array, m

  • phi (numpy.ndarray) – latitude array, rad

  • psi (numpy.ndarray) – heading angle array, rad

  • theta (numpy.ndarray) – longitude array, rad

  • gamma (numpy.ndarray) – flight path angle array, rad

  • drange (numpy.ndarray) – downrange array, meters

  • index (int) – array index of detected event location / max index if no event detected

Returns:

  • t (numpy.ndarray) – truncated time array, sec

  • r (numpy.ndarray) – truncated radial distance array, m

  • v (numpy.ndarray) – truncated speed array, m

  • phi (numpy.ndarray) – truncated latitude array, rad

  • psi (numpy.ndarray) – truncated heading angle array, rad

  • theta (numpy.ndarray) – truncated longitude array, rad

  • gamma (numpy.ndarray) – truncated flight path angle array, rad

  • drange (numpy.ndarray) – truncated downrange array, meters

class AMAT.approach.Approach(arrivalPlanet, v_inf_vec_icrf_kms, rp, psi, is_entrySystem=False, h_EI=None)

Compute the probe/spacecraft approach trajectory for a given v_inf_vec, periapsis radius, psi.

REF: Hughes (2016), Ph.D. Dissertation, Purdue University

planetObj

arrival planet object for approach traje

Type:

AMAT.planet.Planet object

a

semi-major axis, meters

Type:

float

e

eccentricity

Type:

float

beta

true anomaly of the outgoing asymptote, rad

Type:

float

v_inf_vec_bi_kms

v_inf vector in body-inertial frame, km/s

Type:

numpy.ndarray

v_inf_vec_bi

v_inf vector in body-inertial frame, m/s

Type:

numpy.ndarray

v_inf_vec_bi_mag_kms

v_inf magnitude in body-inertial frame, km/s

Type:

float

phi_1

rad, as defined in Eq. (2.16) from REF.

Type:

float

phi_2

rad, as defined in Eq. (2.17) from REF.

Type:

float

rp_vec_bi_unit

periapsis radius unit vector in body-inertial frame

Type:

numpy.ndarray

rp_vec_bi

periapsis radius vector in body-inertial frame, meters

Type:

numpy.ndarray

e_vec_bi_unit

eccentricity unit vector in body-inertial frame

Type:

numpy.ndarray

e_vec_bi

eccentricity vector in body-inertial frame, meters

Type:

numpy.ndarray

h

angular momentum, SI units

Type:

float

h_vec_bi

angular momentum vector in body-inertial frame, SI units

Type:

numpy.ndarray

h_vec_bi_unit

angular momentum unit vector in body-inertial frame, SI units

Type:

numpy.ndarray

i

inclination [0, np.pi], rad

Type:

float

N_vec_bi

node vector in body-inertial frame

Type:

numpy.ndarray

N_vec_bi_unit

node unit vector in body-inertial frame

Type:

numpy.ndarray

OMEGA

right asecension of ascending node, rad

Type:

float

omega

argument of periapsis, rad

Type:

float

N_ref_bi

reference normal vector in body-inertial frame (planet’s spin axis)

Type:

numpy.ndarray

S_vec_bi

S vector in body-inertial frame, meters

Type:

numpy.ndarray

S_vec_bi_unit

S unit vector in body-inertial frame, meters

Type:

numpy.ndarray

T_vec_bi

T vector in body-inertial frame, meters

Type:

numpy.ndarray

T_vec_bi_unit

T unit vector in body-inertial frame, meters

Type:

numpy.ndarray

R_vec_bi

R vector in body-inertial frame, meters

Type:

numpy.ndarray

R_vec_bi_unit

R unit vector in body-inertial frame, meters

Type:

numpy.ndarray

B_vec_bi

B vector in body-inertial frame, meters

Type:

numpy.ndarray

B_vec_bi_unit

B unit vector in body-inertial frame, meters

Type:

numpy.ndarray

b_mag

aim point vector B magnitude, meters

Type:

float

b_plane_angle_theta

angle between aim point vector B and T

Type:

float

r_EI

atmospheric entry interface radius, m

Type:

float

theta_star_entry

true anomaly at entry interface, rad

Type:

float

r_vec_entry_bi

position vector at entry interface in body-inertial frame, meters

Type:

numpy.ndarray

r_vec_entry_bi_unit

position unit vector at entry interface in body-inertial frame, meters

Type:

numpy.ndarray

r_vec_entry_bi_mag

position vector magnitude at entry interface in body-inertial frame, meters

Type:

float

v_entry_inertial_mag

inertial velocity magnitude at entry interface in body-inertial frame, m/s

Type:

float

gamma_entry_inertial

inertial flight path angle at entry interface, rad

Type:

float

v_vec_entry_bi

inertial velocity vector at entry interface in body-inertial frame, m/s

Type:

numpy.ndarray

v_vec_entry_bi_unit

inertial velocity unit vector at entry interface in body-inertial frame, m/s

Type:

numpy.ndarray

gamma_entry_inertial_check

analytic solution for inertial flight path angle at entry interface, rad

Type:

float

latitude_entry_bi

entry latitude in body-inertial frame, rad

Type:

float

longitude_entry_bi

entry longitude in body-inertial frame, rad

Type:

float

v_vec_entry_atm

atmosphere-relative velocity vector at entry interface in body-inertial frame, m/s

Type:

numpy.ndarray

v_entry_atm_mag

atmosphere-relative velocity magnitude at entry interface in body-inertial frame, m/s

Type:

float

v_vec_entry_atm_unit

atmosphere-relative velocity unit vector at entry interface in body-inertial frame, m/s

Type:

numpy.ndarray

gamma_entry_atm

atmosphere-relative flight path angle at entry interface, rad

Type:

float

v_vec_entry_atm_unit_proj

projection of atmosphere-relative vector onto local horizontal plane at entry interface in body-inertial frame

Type:

numpy.ndarray

local_latitude_parallel_vec_unit

unit vector direction of local parallel of latitude at entry interface in body-inertia frame

Type:

numpy.ndarray

heading_entry_atm

atmosphere-relative heading angle at entry interface, rad

Type:

float

BI_to_BI_dprime(X_ICRF)

Converts an input vector from body-inertial to body-inertial-double-prime frame following Eq. (2.10) of REF.

Parameters:

X_ICRF (numpy.ndarray) – row vector in body-inertial frame

Returns:

ans – input vector in body-inertial double-prime frame

Return type:

numpy.ndarray

ICRF_to_BI(X_ICRF)

Converts an input vector from ICRF to body-inertial frame

Parameters:

X_ICRF (numpy.ndarray) – row vector in ICRF frame

Returns:

ans – input vector in body-inertial frame

Return type:

numpy.ndarray

R1(theta)

Direction cosine matrix for rotation about x-axis.

Parameters:

theta (float) – rotation angle about x-axis

Returns:

ans – Direction cosine matrix for rotation about x-axis.

Return type:

numpy.ndarray

R2(theta)

Direction cosine matrix for rotation about y-axis.

Parameters:

theta (float) – rotation angle about y-axis

Returns:

ans – Direction cosine matrix for rotation about y-axis.

Return type:

numpy.ndarray

R3(theta)

Direction cosine matrix for rotation about z-axis.

Parameters:

theta (float) – rotation angle about zaxis

Returns:

ans – Direction cosine matrix for rotation about z-axis.

Return type:

numpy.ndarray

pos_vec_bi(theta_star)

Computes the position vector in body-inertial frame for a specified true-anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

pos_vec_bi – position vector in body-inertial frame, meters

Return type:

numpy.ndarray

pos_vec_bi_dprime(theta_star)

Computes the position vector in body-inertial double-prime frame for a specified true-anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

pos_vec_bi_dprime – position vector in body-inertial double-prime frame, meters

Return type:

numpy.ndarray

r_mag_bi(theta_star)

Computes the position vector magnitude in body-inertial frame at a given true anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

r_mag_bi – position vector magnitude, meters

Return type:

float

vel_vec_bi(theta_star)

Computes the velocity vector magnitude in body-inertial frame at a given true anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

vel_vec_bi – velocity vector in body-inertial frame, m/s

Return type:

numpy.ndarray

vel_vec_entry_atm()

Computes the atmosphere-relative velocity vector magnitude in body-inertial frame at atmospheric entry interface.

Returns:

vel_vec_entry_atm – atmosphere-relative velocity vector in body-inertial frame, at atmospheric entry interface, m/s

Return type:

numpy.ndarray

class AMAT.interplanetary.Interplanetary(ID, datafile, sheet_name, Lcdate_format)

Stores a dataframe containing interplanetary data from an external source.

ID

string identifier for the interplanetary dataset

Type:

str

datafile

Excel file containing interplanetary trajectory data

Type:

filepath

sheet_name

Sheet name containing trajectory data

Type:

str

df

dataframe containing the interplanetary trajectory data

Type:

pandas.DataFrame object

Lcdate

Series containing launch date datetime objects

Type:

pandas.Series

C3

Series containing launch C3

Type:

pandas.Series

TOF

Series containing time of flight, years

Type:

pandas.Series

Avinf

Series containing arrival vinf magnitude, km/s

Type:

pandas.Series

compute_launch_capability(launcherObj)
Parameters:

launcherObj (AMAT.launcher.Launcher object) –

Returns:

ans – array containing the launch mass capability for C3 values in the trajectory dataset

Return type:

numpy.ndarray

plot_Avinf_vs_launch_date()

Scatter plot of the arrival vinf magnitude as a function of launch date.

Returns:

ans – Scatter of the arrival vinf magnitude as a function of launch date

Return type:

matplotlib.figure.Figure

plot_Avinf_vs_launch_date_with_launch_mass_colorbar(launcherObj, scale=20)

Scatter plot of the arrival vinf magnitude as a function of launch date with launch capability colorbar.

Parameters:

  • launcherObj (AMAT.launcher.Launcher object) – AMAT Launcher object

  • scale (float) – scatter plot marker size, defaults to 20

Returns:

ans – Scatter of the arrival vinf magnitude as a function of launch date with launch capability colorbar.

Return type:

matplotlib.figure.Figure

plot_TOF_vs_launch_date()

Scatter plot of the time of flight as a function of launch date.

Returns:

ans – Scatter of the launch capability as a function of launch date

Return type:

matplotlib.figure.Figure

plot_launch_mass_vs_TOF(launcherObj)

Scatter plot of the launch mass as a function of TOF.

Returns:

ans – Scatter plot of the launch mass as a function of TOF.

Return type:

matplotlib.figure.Figure

plot_launch_mass_vs_TOF_with_vinf_colorbar(launcherObj, scale=20)

Scatter plot of the launch mass as a function of TOF with arrival vinf colorbar.

Parameters:

  • launcherObj (AMAT.launcher.Launcher object) – AMAT Launcher object

  • scale (float) – scatter plot marker size, defaults to 20

Returns:

ans – Scatter plot of the launch mass as a function of TOF with arrival vinf colorbar.

Return type:

matplotlib.figure.Figure

plot_launch_mass_vs_launch_date(launcherObj)

Scatter plot of the launch capability as a function of launch date.

Parameters:

launcherObj (AMAT.launcher.Launcher object) – AMAT Launcher object

Returns:

ans – Scatter of the launch capability as a function of launch date

Return type:

matplotlib.figure.Figure

class AMAT.launcher.Launcher(launcherID, datafile, kind='linear')

The Launcher class is used to estimate launch vehicle performance.

launcherID

String identifier for launch vehicle

Type:

str

datafile

CSV file containing C3,launch mass (kg)

Type:

CSV file

kind

type of interpolation to use. Defaults to ‘linear’

Type:

str

f

interpolation function for launch mass at a specified C3

Type:

scipy.interpolate.interp1d

launchMass(C3)

Returns the launch capability of the vehicle for a specified C3 array.

Parameters:

C3 (float) – launch C3, km2/s2

Returns:

mass – launch mass capability, kg

Return type:

float

class AMAT.maneuver.OrbiterOrbiterDeflection(arrivalPlanet, v_inf_vec_icrf_kms, rp_space1, psi_space1, rp_space2, psi_space2, r_dv_rp)

Computes the deflection maneuver delta-V and time of flight for delivering two orbiter spacecraft from an approach trajectory.

planetObj

arrival planet object for approach trajectory

Type:

AMAT.planet.Planet object

space1

Approach object with approach trajectory parameters for the first orbiter spacecraft

Type:

AMAT.approach.Approach object

space2

Approach object with approach trajectory parameters for the second orbiter spacecraft

Type:

AMAT.approach.Approach object

r_dv_rp

radial distance at which the deflection maneuver is performed, in terms of arrival planet radius Example: 1000, for maneuver performed at radial distance of 1000 times the radius of the planet.

Type:

float

r_dv

radial distance at which the deflection maneuver is performed, in meters

Type:

float

theta_star_dv_space1

true anomaly of the first orbiter spacecraft at deflection maneuver, rad

Type:

float

r_vec_dv

position vector at deflection maneuver in body-inertial frame, meters

Type:

numpy.ndarray

r_vec_dv_unit

position unit vector at deflection maneuver in body-inertial frame

Type:

numpy.ndarray

delta_theta_star_space1

true anomaly change for first orbiter spacecraft (Eq. 2.78, REF), rad

Type:

float

delta_theta_star_space2

true anomaly change for second orbiter spacecraft (Eq. 2.78, REF), rad

Type:

float

v_vec_dv_space1

first orbiter spacecraft velocity vector in body-inertial frame, meters

Type:

numpy.ndarray

v_vec_dv_space2

second orbiter spacecraft velocity vector in body-inertial frame, meters

Type:

numpy.ndarray

v_vec_dv_maneuver

deflection maneuver delta-V vector, m/s

Type:

numpy.ndarray

v_vec_dv_maneuver_mag

deflection maneuver delta-V magnitude, m/s

Type:

numpy.ndarray

TOF_space1

first spacecraft orbiter time of flight from deflection maneuver until periapsis, days

Type:

float

TOF_space2

second spacecraft orbiter time of flight from deflection maneuver until periapsis, days

Type:

float

class AMAT.maneuver.ProbeOrbiterDeflection(arrivalPlanet, v_inf_vec_icrf_kms, rp_probe, psi_probe, h_EI_probe, rp_space, psi_space, r_dv_rp)

Computes the deflection manuever delta-V and time of flight for an orbiter spacecraft divert manuever for propulsive orbit insertion after probe release on approach.

planetObj

arrival planet object for approach trajectory

Type:

AMAT.planet.Planet object

probe

Approach object with approach trajectory parameters for the entry probe

Type:

AMAT.approach.Approach object

space

Approach object with approach trajectory parameters for the orbiter spacecraft

Type:

AMAT.approach.Approach object

r_dv_rp

radial distance at which the deflection maneuver is performed, in terms of arrival planet radius Example: 1000, for maneuver performed at radial distance of 1000 times the radius of the planet.

Type:

float

r_dv

radial distance at which the deflection maneuver is performed, in meters

Type:

float

theta_star_dv_probe

true anomaly of the probe at deflection maneuver, rad

Type:

float

r_vec_dv

probe position vector at maneuver in body-inertial frame, meters

Type:

numpy.ndarray

r_vec_dv_unit

probe position unit vector at maneuver in body-inertial frame

Type:

numpy.ndarray

delta_theta_star_probe

true anomaly change for probe (Eq. 2.75, REF), rad

Type:

float

delta_theta_star_space

true anomaly change for orbiter (Eq. 2.78, REF), rad

Type:

float

v_vec_dv_probe

probe velocity vector in body-inertial frame, meters

Type:

numpy.ndarray

v_vec_dv_space

orbiter velocity vector in body-inertial frame, meters

Type:

numpy.ndarray

v_vec_dv_maneuver

orbiter deflection maneuver delta-V vector, m/s

Type:

numpy.ndarray

v_vec_dv_maneuver_mag

orbiter deflection maneuver delta-V magnitude, m/s

Type:

numpy.ndarray

TOF_probe

probe time of flight from deflection maneuver until atmospheric entry interface, days

Type:

float

TOF_space

orbiter time of flight from deflection maneuver until periapsis, days

Type:

float

class AMAT.maneuver.ProbeProbeDeflection(arrivalPlanet, v_inf_vec_icrf_kms, rp_probe1, psi_probe1, h_EI_probe1, rp_probe2, psi_probe2, h_EI_probe2, r_dv_rp)

Computes the deflection maneuver delta-V and time of flight for delivering two atmospheric entry systems from an approach trajectory.

planetObj

arrival planet object for approach trajectory

Type:

AMAT.planet.Planet object

probe1

Approach object with approach trajectory parameters for the first entry probe

Type:

AMAT.approach.Approach object

probe2

Approach object with approach trajectory parameters for the second entry probe

Type:

AMAT.approach.Approach object

r_dv_rp

radial distance at which the deflection maneuver is performed, in terms of arrival planet radius Example: 1000, for maneuver performed at radial distance of 1000 times the radius of the planet.

Type:

float

r_dv

radial distance at which the deflection maneuver is performed, in meters

Type:

float

theta_star_dv_probe1

true anomaly of the first probe at deflection maneuver, rad

Type:

float

theta_star_dv_probe2

true anomaly of the second probe at deflection maneuver, rad

Type:

float

delta_theta_star_probe1

true anomaly change for first probe (Eq. 2.75, REF), rad

Type:

float

delta_theta_star_probe2

true anomaly change for second probe (Eq. 2.75, REF), rad

Type:

float

v_vec_dv_probe1

first probe velocity vector in body-inertial frame, meters

Type:

numpy.ndarray

v_vec_dv_probe2

second probe velocity vector in body-inertial frame, meters

Type:

numpy.ndarray

v_vec_dv_maneuver

deflection maneuver delta-V vector, m/s

Type:

numpy.ndarray

v_vec_dv_maneuver_mag

deflection maneuver delta-V magnitude, m/s

Type:

numpy.ndarray

TOF_probe1

probe time of flight from deflection maneuver until atmospheric entry interface, days

Type:

float

TOF_probe2

orbiter time of flight from deflection maneuver until atmospheric entry interface, days

Type:

float

class AMAT.orbiter.Orbiter(vehicle, peri_alt_km)

Compute the coast trajectory from atmospheric exit until apoapsis, the periapsis raise manuever dv, and the first full orbit post aerocapture. Also computes the probe trajectory following a probe-targeting maneuver, probe atmospheric entry conditions, and the orbiter trajectory following an orbiter deflection manuever.

vehicle

Vehicle object which has been propagated until atmospheric exit

Type:

AMAT.vehicle.Vehicle

peri_alt_km

target orbit periapsis altitude, km

Type:

float

r_periapsis_mag

target orbit periapsis radial distance, m

Type:

float

terminal_r

planet-relative atmospheric exit state terminal radial distance, m

Type:

float

terminal_theta

planet-relative atmospheric exit state terminal longitude, rad

Type:

float

terminal_phi

planet-relative atmospheric exit state terminal latitude, rad

Type:

float

terminal_v

planet-relative atmospheric exit state terminal speed, m/s

Type:

float

terminal_g

planet-relative atmospheric exit state terminal flight-path angle, rad

Type:

float

terminal_psi

planet-relative atmospheric exit state terminal heading angle, rad

Type:

float

terminal_r_vec

planet-relative atmospheric exit state radius vector, m

Type:

numpy.ndarray

terminal_r_hat_vec

planet-relative atmospheric exit state radius unit vector

Type:

numpy.ndarray

terminal_v_vec

planet-relative atmospheric exit state velocity vector, m/s

Type:

numpy.ndarray

terminal_r_hat_vec

planet-relative atmospheric exit state velocity unit vector

Type:

numpy.ndarray

terminal_v_ie_vec

inertial atmospheric exit state velocity vector, m/s

Type:

numpy.ndarray

terminal_v_ie_hat_vec

inertial atmospheric exit state velocity unit vector

Type:

numpy.ndarray

terminal_fpa_ie_deg

inertial atmospheric exit state flight-path angle, deg

Type:

float

terminal_fpa_ie_rad

inertial atmospheric exit state flight-path angle, rad

Type:

float

terminal_r_bi

body-inertial atmospheric exit state terminal radial distance, m

Type:

float

terminal_theta_bi

body-inertial atmospheric exit state terminal longitude, rad

Type:

float

terminal_phi_bi

body-inertial atmospheric exit state terminal latitude, rad

Type:

float

terminal_v_bi

body-inertial atmospheric exit state terminal speed, m/s

Type:

float

terminal_g_bi

body-inertial atmospheric exit state terminal flight-path angle, rad

Type:

float

terminal_psi_bi

body-inertial atmospheric exit state terminal heading angle, rad

Type:

float

terminal_E

orbit total specific energy at atmospheric exit

Type:

float

terminal_h

orbit specific angular momentum scalar at atmospheric exit

Type:

float

a

initial capture orbit semi-major axis, m

Type:

float

e

initial capture orbit eccentricity

Type:

float

i

initial capture inclination, rad

Type:

float

h

initial capture specific angular momentum, SI units

Type:

float

OMEGA

initial capture RAAN, rad

Type:

float

omega

initial capture AoP, rad

Type:

float

theta_star_exit

true anomaly at atmospheric exit, rad

Type:

float

x_coast_arr

body-inertial x-coordinate positions of coast trajectory from atmospheric exit until apoapsis, in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

y_coast_arr

body-inertial y-coordinate positions of coast trajectory from atmospheric exit until apoapsis, in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

z_coast_arr

body-inertial z-coordinate positions of coast trajectory from atmospheric exit until apoapsis, in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

r_apoapsis_vec

body-inertial radial vector of apoapsis, in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

r_apoapsis_mag

body-inertial radial apoapsis distance, m

Type:

float

v_apoapsis_vec_coast

body-inertial velocity vector at apoapsis for coast orbit, m/s

Type:

float

v_apoapsis_mag_coast

body-inertial velocity vector magnitude at apoapsis for coast orbit, m/s

Type:

float

v_apoapsis_vec_orbit

body-inertial velocity vector at apoapsis for final orbit, m/s

Type:

numpy.ndarray

v_apoapsis_mag_orbit

body-inertial velocity vector magnitude at apoapsis for final orbit, m/s

Type:

float

PRM_dv_vec

periapsis raise manuever delta-V vector, m/s

Type:

numpy.ndarray

PRM_dv_mag

periapsis raise manuever delta-V magnitude, m/s

Type:

float

x_orbit_arr

body-inertial x-coordinate positions of one full final orbit after PRM in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

y_orbit_arr

body-inertial y-coordinate positions of one full final orbit after PRM in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

z_orbit_arr

body-inertial z-coordinate positions of one full final orbit after PRM in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

theta_star_probe_targeting

true anomaly of the probe targeting manuever, from the initial capture orbit [0, 2*pi], rad

Type:

float

a_probe_orbit

probe approach orbit semi-major axis, m

Type:

float

e_probe_orbit

probe approach eccentricity

Type:

float

i_probe_orbit

probe approach inclination, rad

Type:

float

h_probe_orbit

probe approach specific angular momentum, SI units

Type:

float

OMEGA_probe_orbit

probe approach RAAN, rad

Type:

float

omega_probe_orbit

probe approach AoP, rad

Type:

float

r_periapsis_probe

periapsis radius of probe approach trajectory, m

Type:

float

r_apoapsis_probe

apoapsis radius of probe approach trajectory, m

Type:

float

h_periapsis_probe

periapsis altitude of probe approach trajectory, m

Type:

float

h_EI

probe atmospheric interface altitude, m

Type:

float

r_EI

probe atmospheric interface radius, m

Type:

float

theta_star_probe_entry

true anomaly at probe atmospheric entry, rad

Type:

float

r_vec_bi_probe_entry

position vector at probe atmospheric entry, m

Type:

numpy.ndarray

r_vec_bi_probe_entry_unit

unit position vector at probe atmospheric entry

Type:

numpy.ndarray

r_vec_bi_probe_entry_mag

position vector magnitude at probe atmospheric entry, m

Type:

float

v_bi_vec_probe_entry

inertial velocity vector at probe atmospheric entry, m/s

Type:

numpy.ndarray

v_bi_mag_probe_entry

inertial velocity magnitude at probe atmospheric entry, m/s

Type:

float

v_bi_vec_probe_entry_unit

unit inertial velocity vector at probe atmospheric entry, m/s

Type:

numpy.ndarray

gamma_inertial_probe_entry

inertial flight-path angle at probe atmospheric entry, rad

Type:

float

latitude_probe_entry_bi

inertial latitude at probe atmospheric entry, rad

Type:

float

longitude_probe_entry_bi

inertial longitude at probe atmospheric entry, rad

Type:

float

v_vec_probe_entry_atm

atmosphere-relative velocity vector at probe atmospheric entry, m/s

Type:

numpy.ndarray

v_mag_probe_entry_atm

atmosphere-relative velocity magnitude at probe atmospheric entry, m/s

Type:

float

v_vec_probe_entry_atm_unit

atmosphere-relative velocity unit vector at probe atmospheric entry, m/s

Type:

numpy.ndarray

gamma_atm_probe_entry

atmosphere-relative flight-path angle at probe atmospheric entry, rad

Type:

float

v_atm_probe_entry_unit_proj

atmosphere-relative velocity unit vector projection on local horizontal plane

Type:

numpy.ndarray

atm_probe_entry_local_latitude_parallel_vec_unit

local parallel of latitude unit vector at probe atmospheric entry interface

Type:

numpy.ndarray

heading_atm_probe_entry

atmosphere-relative heading angle at probe atmospheric entry, rad

Type:

float

x_probe_arr

body-inertial x-coordinate positions of probe approach trajectory from probe targeting manuever until atmospheric entry in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

y_probe_arr

body-inertial y-coordinate positions of probe approach trajectory from probe targeting manuever until atmospheric entry in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

z_probe_arr

body-inertial z-coordinate positions of probe approach trajectory from probe targeting manuever until atmospheric entry in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

dV_mag_probe_targeting

probe targeting maneuver delta-V magnitude, m/s

Type:

float

dV_vec_probe_targeting

probe targeting maneuver delta-V vector, m/s

Type:

float

theta_star_orbiter_defl

true anomaly of the orbiter deflection maneuever, from the probe targeting orbit [0, 2*pi], rad

Type:

float

a_orbiter_defl

orbiter deflection orbit semi-major axis, m

Type:

float

e_orbiter_defl

orbiter deflection orbit eccentricity

Type:

float

i_orbiter_defl

orbiter deflection orbit inclination, rad

Type:

float

h_orbiter_defl

orbiter deflection orbit specific angular momentum, SI units

Type:

float

OMEGA_orbiter_defl

orbiter deflection orbit approach RAAN, rad

Type:

float

omega_orbiter_defl

orbiter deflection AoP, rad

Type:

float

r_periapsis_orbiter_defl

periapsis radius of orbiter deflection orbit trajectory, m

Type:

float

r_apoapsis_orbiter_defl

apoapsis radius of orbiter deflection orbit trajectory, m

Type:

float

h_periapsis_orbiter_defl

periapsis altitude of orbiter deflection orbit, m

Type:

float

x_orbiter_defl_arr

body-inertial x-coordinate positions of orbiter deflection trajectory in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

y_orbiter_defl_arr

body-inertial y-coordinate positions of orbiter deflection trajectory in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

z_orbiter_defl_arr

body-inertial z-coordinate positions of orbiter deflection trajectory in non-dimensional units in terms of planet radius (vehicle.planetObj.RP)

Type:

numpy.ndarray

dV_mag_orbiter_defl

orbiter deflection maneuver delta-V magnitude, m/s

Type:

float

dV_vec_orbiter_defl

orbiter deflection maneuver delta-V vector, m/s

Type:

float

compute_PRM_dv()

Computes the periapsis raise manuever delta-V vector and magnitude

compute_coast_orbital_elements()

Computes the orbital elements of the coast phase

compute_coast_trajectory(num_points=301)

Computes the coast trajectory from atmospheric exit until first apoapsis

Parameters:

num_points (int) – number of grid points

compute_exit_state_atm_relative()

Extracts the exit state vector in atmosphere relative coordinates from the propagated vehicle exit state.

compute_exit_state_inertial()

Computes the exit state vector in body inertial frame.

compute_orbit_trajectory(num_points=601)

Computes the coordinates of initial capture orbit after periapsis raise manuever

Parameters:

num_points (int) – grid points for full final orbit trajectory

compute_orbiter_deflection_trajectory(theta_star, dV, num_points=601)

Computes the coordinates of orbiter deflection trajectory following an orbiter deflection manuever at theta_star of the probe approach trajectory orbit.

Parameters:

  • theta_star (float) – true anomaly of the probe approach trajectory orbit at which the orbiter deflection manuever is performed [0,2pi], rad

  • dV (float) – delta-V magnitude of the orbiter deflection manuever, along the direction of orbital velocity, can be positive or negative. Must be positive to raise the periapsis outside the atmosphere. m/s

  • num_points (int) – number of grid points for the orbiter deflection trajectory

compute_post_PRM_orbital_elements()

Computes the orbit elements for orbit with periapsis raised

compute_probe_targeting_trajectory(theta_star, dV, num_points=301)

Computes the coordinates of probe approach trajectory following a probe targeting manuever at theta_star of the initial capture orbit.

Parameters:

  • theta_star (float) – true anomaly of the initial capture orbit at which the probe targeting maneuever is performed [0,2pi], rad

  • dV (float) – delta-V magnitude of the probe targeting maneuver, along the direction of orbital velocity, can be positive or negative. Must be negative to deliver probe into the atmosphere from the initial capture orbit. m/s

  • num_points (int) – number of grid points for the probe approach trajectory

pos_vec_bi(theta_star)

Computes the position vector in body-inertial frame for a specified true-anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

pos_vec_bi – position vector in body-inertial frame, meters

Return type:

numpy.ndarray

pos_vec_bi_orbiter_defl(theta_star)

Computes the position vector in body-inertial frame of the orbiter deflection trajectory for a specified true-anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

pos_vec_bi – position vector in body-inertial frame, meters

Return type:

numpy.ndarray

pos_vec_bi_probe(theta_star)

Computes the position vector in body-inertial frame of the probe trajectory for a specified true-anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

pos_vec_bi – position vector in body-inertial frame, meters

Return type:

numpy.ndarray

r_mag_bi(theta_star)

Computes the position vector magnitude in body-inertial frame at a given true anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

r_mag_bi – position vector magnitude, meters

Return type:

float

vel_vec_bi(theta_star)

Computes the velocity vector in body-inertial frame at a given true anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

vel_vec_bi – velocity vector in body-inertial frame, m/s

Return type:

numpy.ndarray

vel_vec_bi_probe(theta_star)

Computes the velocity vector in body-inertial frame for the probe trajectory at a given true anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

vel_vec_bi – velocity vector in body-inertial frame, m/s

Return type:

numpy.ndarray

vel_vec_probe_entry_atm()

Computes the atmosphere-relative velocity vector magnitude in body-inertial frame of the probe at atmospheric entry interface.

Returns:

vel_vec_entry_atm – atmosphere-relative velocity vector in body-inertial frame, at atmospheric entry interface, m/s

Return type:

numpy.ndarray

class AMAT.orbiter.PropulsiveOrbiter(approach, apoapsis_alt_km)

Compute the orbit of a propulsive insertion orbiter after OI burn.

compute_orbit_trajectory(num_points=601)

Computes the coordinates of initial capture orbit of the propulsive orbiter

Parameters:

num_points (int) – grid points for full final orbit trajectory

compute_timed_orbit_trajectory(t_seconds, num_points=101)

Computes the coordinates of initial capture orbit of the propulsive orbiter as a function of time.

Parameters:

  • t_seconds (float) – time to compute the orbit trajectory from periapsis, seconds

  • num_points (int) – number of grid points in the time interval

pos_vec_bi(theta_star)

Computes the position vector in body-inertial frame for a specified true-anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

pos_vec_bi – position vector in body-inertial frame, meters

Return type:

numpy.ndarray

r_mag_bi(theta_star)

Computes the position vector magnitude in body-inertial frame at a given true anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

r_mag_bi – position vector magnitude, meters

Return type:

float

vel_vec_bi(theta_star)

Computes the velocity vector in body-inertial frame at a given true anomaly.

Parameters:

theta_star (float) – true anomaly, rad

Returns:

vel_vec_bi – velocity vector in body-inertial frame, m/s

Return type:

numpy.ndarray

class AMAT.visibility.LanderToOrbiter(planet, latitude, orbiter, t_seconds, num_points=1600)

Computes the range and elevation of an orbiter from a landing site on an observer planet over for a specified duration of time in seconds. This can be used to analyze the lander to relay orbiter data link from a stationary lander (say on Mars or Titan).

t_array

array containing timestamps at which lander and orbiter positions are computed, seconds

Type:

numpy.ndarray

longitude_rate

longitude advance rate, deg/s

Type:

float

longitude_array

array containing longitudes at which positions are computed, degrees

Type:

numpy.ndarray

lander_pos_x_bi_arr

array containing lander position X coordinate in body inertial frame, meters

Type:

numpy.ndarray

lander_pos_y_bi_arr

array containing lander position Y coordinate in body inertial frame, meters

Type:

numpy.ndarray

lander_pos_z_bi_arr

array containing lander position Z coordinate in body inertial frame, meters

Type:

numpy.ndarray

orbiter_pos_x_bi_arr

array containing orbiter position X coordinate in body inertial frame, meters

Type:

numpy.ndarray

orbiter_pos_y_bi_arr

array containing orbiter position Y coordinate in body inertial frame, meters

Type:

numpy.ndarray

orbiter_pos_z_bi_arr

array containing orbiter position Z coordinate in body inertial frame, meters

Type:

numpy.ndarray

range_array

array containing lander-to-orbiter range values, meters

Type:

numpy.ndarray

beta_array

array containing lander-to-orbiter beta angle values, degrees

Type:

numpy.ndarray

elevation_array

array containing lander-to-orbiter elevation angle values, degrees

Type:

numpy.ndarray

visible_array

boolean array containing visibility of lander to orbiter, True or False

Type:

numpy.ndarray

class AMAT.visibility.LanderToPlanet(target_planet, observer_planet, latitude, date, num_points=101, ephem_file='../spice-data/de432s.bsp')

Computes the range and elevation of a target planet from a site on an observer planet over one full rotation of the observer planet. This can be used to analyze the DTE data link from a stationary lander (say on Mars or Titan) to Earth.

planetObj

object for the observer planet

Type:

AMAT.planet.Planet

observer_planet

observer planet

Type:

str

target_planet

target planet

Type:

str

a0

observer planet north pole right ascension wrt ICRF

Type:

float

d0

observer planet north pole declination wrt ICRF

Type:

float

arrival_date

datetime object with scale=tdb

Type:

astropy.time.Time object

longitude_array

body inertial longitude array, degrees

Type:

numpy.ndarray

t_array

array containing timestamps at which lander position is computed, seconds

Type:

numpy.ndarray

range

range from observer to target, meters

Type:

float

beta_array

beta angle array, degrees

Type:

numpy.ndarray

elevation_array

elevation angle array, degrees

Type:

numpy.ndarray

visible_array

boolean array containing visibility of lander to orbiter, True or False

Type:

numpy.ndarray

class AMAT.visibility.OrbiterToPlanet(target_planet, observer_planet, orbiter, date, t_seconds, num_points=1600, ephem_file='../spice-data/de432s.bsp')

Computes the visibility of a target planet from an orbiter at another planet for a specified duration of time in seconds. The target planet will be periodically eclipsed by the planet around which the spacecraft is orbiting. This can be used to analyze the relay orbiter data link to Earth.

range

range from observer to target, meters

Type:

float

obs_tar_pos_vec_bi_unit

observer to target unit vector in BI frame

Type:

numpy.ndarray

t_array

array containing timestamps at which target planet visibility is computed, seconds

Type:

numpy.ndarray

visible_array

boolean array containing visibility of orbiter to target planet, True or False

Type:

numpy.ndarray

class AMAT.visibility.Visibility

Base class used by other classes in AMAT.visibility. Contains functions to convert a vector from ICRF to BI frame.

ICRF_to_BI(X_ICRF)

Converts an input vector from ICRF to body-inertial frame

Parameters:

X_ICRF (numpy.ndarray) – row vector in ICRF frame

Returns:

ans – input vector in body-inertial frame

Return type:

numpy.ndarray

R1(theta)

Direction cosine matrix for rotation about x-axis.

Parameters:

theta (float) – rotation angle about x-axis

Returns:

ans – Direction cosine matrix for rotation about x-axis.

Return type:

numpy.ndarray

R2(theta)

Direction cosine matrix for rotation about y-axis.

Parameters:

theta (float) – rotation angle about y-axis

Returns:

ans – Direction cosine matrix for rotation about y-axis.

Return type:

numpy.ndarray

R3(theta)

Direction cosine matrix for rotation about z-axis.

Parameters:

theta (float) – rotation angle about zaxis

Returns:

ans – Direction cosine matrix for rotation about z-axis.

Return type:

numpy.ndarray

Computes the link budget for a telecom link.

freq

Frequency, Hz

Type:

float

wavelength

Wavelength, m

Type:

float

Pt

Transmitter power, W

Type:

float

Pt_dB

Transmitter power, dBW

Type:

float

Lt_dB

Transmitter antenna loss, dB

Type:

float

L_sc_dB

Spacecraft circuit loss, dB

Type:

float

Dt

Transmitter antenna diameter, m

Type:

float

At

Transmitter antenna area, m2

Type:

float

eta_t

Transmitter antenna efficiency

Type:

float

Gt_dBi

Transmitter antenna gain, dBi Computed using Dt and eta_t if provided, or from Gt_dBi

Type:

float

Dr

Receiver antenna diameter, m

Type:

float

Ar

Receiver antenna area, m2

Type:

float

eta_r

Receiver antenna efficiency

Type:

float

Gr_dBi

Receiver gain, dBi Computed using Dr and eta_r if provided, or from Gr_dBi

Type:

float

Ts

System Noise Temperature, K

Type:

float

Ts_dBK

System Noise Temperature, dBK

Type:

float

range

Link distance, m

Type:

float

Ls_dB

Free space loss, dB

Type:

float

La_dB

Atmospheric attenuation, dB

Type:

float

L_other_dB

Other losses, dB

Type:

float

L_DSN_dB

DSN System Loss, dB

Type:

float

Ka_dB

Boltzmann’s constant term

Type:

float

R

Data rate, bps

Type:

float

R_dBHz

Data rate, dBHz

Type:

float

EB_N0_req

Required Eb/N0

Type:

float

EB_N0

Required Eb/N0

Type:

float

EB_N0_margin

Eb/N0 margin

Type:

float

compute_antenna_gain(eta, D, wavelength)
Parameters:

  • eta (float) – antenna efficiency

  • D (float) – antenna diameter, m

  • wavelength (float) – wavelength, m

Returns:

ans – antenna gain, before converting to dBi

Return type:

float

compute_dB(X)
Parameters:

X (float) – any parameter to be converted to dB

Returns:

ans – Power in dBW

Return type:

float

compute_data_volume(visibility, schedule)
Parameters:
compute_free_space_loss_dB(range, wavelength)
Parameters:

  • range (float) – link distance, m

  • wavelength (float) – wavelength, m

Returns:

ans – free space loss, dB

Return type:

float