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

Returns

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. –

Returns

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.arrival.Arrival

Compute the arrival declination from either a user-supplied v_inf vector in ICRF, or a v_inf_vector computed from a Lambert arc (last planetary encounter prior to arrival anf arrival date)

v_inf_vec

v_inf vector, km/s

Type

numpy.ndarray

v_inf_mag

v_inf magnitude, km/s

Type

float

v_inf_vec_unit

v_inf unit vector

Type

numpy.ndarray

north_pole

north pole direction in ICRF unit vector

Type

numpy.ndarray

angle

angle between v_inf_vec and planet north pole, rad

Type

float

declination

arrival declination, angle between v_inf_vec and planetary equator

Type

float

compute_declination()

Returns

self.declination – returns the computed arrival declination, rad

Return type

float

compute_v_inf_mag()

Returns

self.v_inf_mag – returns the computed v_inf magnitude in ICRF, km/s

Return type

float

compute_v_inf_vector()

Returns

self.v_inf_vec – returns the manually set / computed v_inf_vec in ICRF, km/s

Return type

numpy.ndarray

set_vinf_vec_from_lambert_arc(lastFlybyPlanet, arrivalPlanet, lastFlybyDate, arrivalDate, M=0, numiter=100, rtol=1e-06, ephem_file='../spice-data/de432s.bsp')

Compute the v_inf_vec from a lambert arc solution if the last flyby date and the arrival date is known

Parameters

• lastFlybyPlanet (str) – Name of the last flyby planet, must be all uppercase Valid entries are: ‘VENUS’, ‘EARTH’, ‘MARS’, ‘JUPITER’, ‘SATURN’, ‘TITAN’, ‘URANUS’, ‘NEPTUNE’

• arrivalPlanet (str) –

  Name of the arrival planet, must be all uppercase;

  Valid entries are: ‘VENUS’, ‘EARTH’, ‘MARS’, ‘JUPITER’, ‘SATURN’, ‘TITAN’, ‘URANUS’, ‘NEPTUNE’

• lastFlybyDate (astropy.time.Time object) – last planetary flyby date-time before arrival, scale = tdb (Barycentric Dynamical Time) example: Time(“2036-03-28 00:00:00”, scale=’tdb’)

• arrivalDate (astropy.time.Time object) – planetary arrival date-time at destination, scale = tdb (Barycentric Dynamical Time) example: Time(“2036-03-28 00:00:00”, scale=’tdb’)

• M (int, optional) – number of full revolutions for Lambert solution defaults to 0

• numiter (int, optional) – maximum number of iterations defaults to 100

• rtol (float, optional) – relative tolerance for lambert solver defaults to 1e-6

• ephem_file (str) – ephemeris filepath to spice-data/de432.bsp

set_vinf_vec_manually(arrivalPlanet, v_inf_vec_ICRF_kms)

Set arrival v_inf_vec manually if available

Parameters

• arrivalPlanet (str) – Name of the planetary body, must be all uppercase Valid entries are: ‘VENUS’, ‘EARTH’, ‘MARS’, ‘JUPITER’, ‘SATURN’, ‘TITAN’, ‘URANUS’, ‘NEPTUNE’

• v_inf_vec_ICRF_kms (numpy.ndarray) – v_inf vector in ICRF, km/s

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

class AMAT.telecom.Link(freq, Pt, Ts, range_km, L_other_dB, rate_kbps, Eb_N0_req, Dt=None, eta_t=None, Gt_dBi=None, Dr=None, eta_r=None, Gr_dBi=None, Lt_dB=1.0, L_sc_dB=0.2, La_dB=0.35, L_DSN_dB=1.0)

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

• visibility (one of AMAT.visibility.LanderToPlanet, AMAT.visibility.LanderToOrbiter,) – AMAT.visibility.OrbiterToPlanet objects

• schedule (AMAT.telecom.Schedule) – Transmit schedule

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