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:
- Abar
vehicle non-dimensional reference area
- Type:
float
- mbar
vehicle non-dimensional mass
- Type:
float
- CD
vehicle drag coefficient
- Type:
float
- CL
vehicle lift coefficient
- Type:
float
- h0_km
initial vehicle altitude at atmospheric interface / other start point, meters
- Type:
float
- theta0_deg
initial vehicle longitude at atmospheric interface / other start point, degrees
- Type:
float
- phi0_deg
initial vehicle latitude at atmospheric interface / other start point, degrees
- Type:
float
- v0_kms
initial vehicle speed (planet-relative) at atmospheric interface / other start point, km/s
- Type:
float
- psi0_deg
initial vehicle heading at atmospheric interface / other start point, degrees
- Type:
float
- gamma0_deg
initial vehicle flight-path angle at atmospheric interface / other start point, degrees
- Type:
float
- drange0_km
initial vehicle downrange at atmospheric interface / other start point, km
- Type:
float
- heatLoad0
initial vehicle heatload at atmospheric interface / other start point, J/cm2
- Type:
float
- tol
solver tolerance, currently both abstol and reltol are set to this value
- Type:
float
- index
array index of the event location if one was detected, terminal index otherwise
- Type:
int
- exitflag
flag to indicate and classify event occurence or lack of it
- Type:
int
- tc
truncated time array, sec
- Type:
numpy.ndarray
- rc
truncated radial distance array, m
- Type:
numpy.ndarray
- thetac
truncated longitude solution array, rad
- Type:
numpy.ndarray
- phic
truncated latitude solution, rad
- Type:
numpy.ndarray
- vc
truncated speed solution array, m/s
- Type:
numpy.ndarray
- psic
truncated heading angle solution, rad
- Type:
numpy.ndarray
- gammac
truncated flight-path angle solution, rad
- Type:
numpy.ndarray
- drangec
truncated downrange solution array, m
- Type:
numpy.ndarray
- t_minc
truncated time array, minutes
- Type:
numpy.ndarray
- h_kmc
truncated altitude array, km
- Type:
numpy.ndarray
- v_kmsc
truncated speed array, km/s
- Type:
numpy.ndarray
- phi_degc
truncated latitude array, deg
- Type:
numpy.ndarray
- psi_degc
truncated heading angle, deg
- Type:
numpy.ndarray
- theta_degc
truncated longitude array, deg
- Type:
numpy.ndarray
- gamma_degc
truncared flight-path angle array, deg
- Type:
numpy.ndarray
- drange_kmc
truncated downrange array, km
- Type:
numpy.ndarray
- acc_net_g
acceleration load solution, Earth G
- Type:
numpy.ndarray
- acc_drag_g
drag acceleration solution, Earth G
- Type:
numpy.ndarray
- dyn_pres_atm
dynamic pressure solution, Pa
- Type:
numpy.ndarray
- stag_pres_atm
stagnation pressure solution, Pa
- Type:
numpy.ndarray
- q_stag_con
stagnation-point convective heat rate, W/cm2
- Type:
numpy.ndarray
- q_stag_rad
stagnation-point radiative heat rate, W/cm2
- Type:
numpy.ndarray
- q_stag_total
stagnation-point radiative tottal heat rate, W/cm2
- Type:
numpy.ndarray
- heatload
stagnation point heat load, J/cm2
- Type:
numpy.ndarray
- maxRollRate
maximum allowed roll rate, degrees per second
- Type:
float
- beta1
beta1 (smaller ballistic coeff.) for drag modulation, kg/m2
- Type:
float
- betaRatio
ballistic coefficient ratio for drag modulation
- Type:
float
- target_peri_km
vehicle target periapsis altitude, km
- Type:
float
- target_apo_km
vehicle target apoapsis altitude, km
- Type:
float
- target_apo_km_tol
vehicle target apoapsis altitude error tolerance, km used by guidance algorithm
- Type:
float
- Ghdot
Ghdot term for vehicle equilibrium glide phase
- Type:
float
- Gq
Gq term for vehicle equilibrium glide phase guidance
- Type:
float
- v_switch_kms
speed below which eq. glide phase is terminated
- Type:
float
- t_step_array
time step array for guided aerocapture trajectory, min
- Type:
numpy.ndarray
- delta_deg_array
bank angle array for guided aerocapture trajectory, deg
- Type:
numpy.ndarray
- hdot_array
altitude rate array for guided aerocapture trajectory, m/s
- Type:
numpy.ndarray
- hddot_array
altitude acceleration array for guided aerocapture, m/s2
- Type:
numpy.ndarray
- qref_array
reference dynamic pressure array for guided aerocapture, Pa
- Type:
numpy.ndarray
- q_array
actual dynamic pressure array for guided aerocapture, Pa
- Type:
numpy.ndarray
- h_step_array
altitude array for guided aerocapture, meters
- Type:
numpy.ndarray
- acc_step_array
acceleration array for guided aerocapture, Earth G
- Type:
numpy.ndarray
- acc_drag_array
acceleration due to drag for guided aerocapture, Earth G
- Type:
numpy.ndarray
- density_mes_array
measured density array during descending leg, kg/m3
- Type:
numpy.ndarray
- density_mes_int
measured density interpolation function
- Type:
scipy.interpolate.interpolate.interp1d
- minAlt
minimum altitude at which density measurement is available, km
- Type:
float
- lowAlt_km
lower altitude to which density model is to be extrapolated based on available measurements, km
- Type:
float
- numPoints_lowAlt
number of points to evaluate extrapolation at below the altitude where measurements are available
- Type:
int
- hdot_threshold
threshold altitude rate (m/s) above which density measurement is terminated and apoapsis prediction is initiated
- Type:
float
- t_min_eg
time solution of equilibrium glide phase, min
- Type:
numpy.ndarray
- h_km_eg
altitude array of equilibrium glide phase, km
- Type:
numpy.ndarray
- v_kms_eg
speed solution of equilibrium glide phase, km/s
- Type:
numpy.ndarray
- theta_deg_eg
longitude solution of equilibrium glide phase, deg
- Type:
numpy.ndarray
- phi_deg_eg
latitude solution of equilibrium glide phase, deg
- Type:
numpy.ndarray
- psi_deg_eg
heading angle solution of equilibrium glide phase, deg
- Type:
numpy.ndarray
- gamma_deg_eg
flight-path angle solution of eq. glide phase, deg
- Type:
numpy.ndarray
- drange_km_eg
downrange solution of eq. glide phase, km
- Type:
numpy.ndarray
- acc_net_g_eg
acceleration solution of eq. glide phase, Earth G
- Type:
numpy.ndarray
- dyn_pres_atm_eg
dynamic pressure solution of eq. glide phase, atm
- Type:
numpy.ndarray
- stag_pres_atm_eg
stagnation pressure solution of eq. glide phase, atm
- Type:
numpy.ndarray
- q_stag_total_eg
stag. point total heat rate of eq. glide phase, W/cm2
- Type:
numpy.ndarray
- heatload_eg
stag. point heatload solution of eq. glide phase, J/cm2
- Type:
numpy.ndarray
- t_switch
swtich time from eq. glide to exit phase, min
- Type:
float
- h_switch
altitude at which guidance switched to exit phase, km
- Type:
float
- v_switch
speed at which guidance switched to exit phase, km/s
- Type:
float
- p_switch
bank angle at which guidance switched to exit phase, deg
- Type:
float
- t_min_full
time solution of full (eq. gllide + exit phase), min
- Type:
numpy.ndarray
- h_km_full
altitude array of full (eq. gllide + exit phase), km
- Type:
numpy.ndarray
- v_kms_full
speed solution of full (eq. gllide + exit phase), km/s
- Type:
numpy.ndarray
- theta_deg_full
longitude solution of full (eq. gllide + exit phase), deg
- Type:
numpy.ndarray
- phi_deg_full
latitude solution of full (eq. gllide + exit phase), deg
- Type:
numpy.ndarray
- psi_deg_full
heading angle solution of full (eq. gllide + exit phase), deg
- Type:
numpy.ndarray
- gamma_deg_full
flight-path angle solution of full (eq. gllide + exit phase), deg
- Type:
numpy.ndarray
- drange_km_full
downrange solution of full (eq. gllide + exit phase), km
- Type:
numpy.ndarray
- acc_net_g_full
acceleration solution of full (eq. gllide + exit phase), Earth G
- Type:
numpy.ndarray
- dyn_pres_atm_full
dynamic pressure solution of full (eq. gllide + exit phase), atm
- Type:
numpy.ndarray
- stag_pres_atm_full
stagnation pressure solution of full (eq. gllide + exit phase), atm
- Type:
numpy.ndarray
- q_stag_total_full
stag. point total heat rate of full (eq. gllide + exit phase), W/cm2
- Type:
numpy.ndarray
- heatload_full
stag. point heatload solution of full (eq. gllide + exit phase), J/cm2
- Type:
numpy.ndarray
- NPOS
NPOS value from GRAM model output is the number of data points (altitude) in each atm. profile
- Type:
int
- NMONTE
NMONTE is the number of Monte Carlo atm profiles from GRAM model output
- Type:
int
- heightCol
column number of altitude values in Monte Carlo density file
- Type:
int
- densLowCol
column number of low density value in Monte Carlo density file
- Type:
int
- densAvgCol
column number of avg. density value in Monte Carlo density file
- Type:
int
- densHighCol
column number of high density value in Monte Carlo density file
- Type:
int
- densTotalCol
column number of total density value in Monte Carlo density file
- Type:
int
- heightInKmFlag
set to True if height values are in km
- Type:
bool
- nominalEFPA
nominal entry-flight-path angle
- Type:
float
- EFPA_1sigma_value
1-sigma error for EFPA
- Type:
float
- nominalLD
nominal vehicle lift-to-drag ratio
- Type:
float
- LD_1sigma_value
1-sigma error for vehicle lift-to-drag ratio
- Type:
float
- vehicleCopy
copy of the original vehicle object
- Type:
Vehicle.vehicle
- timeStep
guidance cycle time, sec
- Type:
float
- dt
max. solver timestep, sec
- Type:
float
- maxTimeSecs
maximum propogation time used by guidance algorithm, sec
- Type:
float
- t_min_en
time solution of entry phase (DM), min
- Type:
numpy.ndarray
- h_km_en
altitude solution of entry phase (DM), km
- Type:
numpy.ndarray
- v_kms_en
velocity solution of entry phase (DM), km/s
- Type:
numpy.ndarray
- theta_deg_en
longitude solution of entry phase (DM), deg
- Type:
numpy.ndarray
- phi_deg_en
latitude solution of entry phase (DM), deg
- Type:
numpy.ndarray
- psi_deg_en
heading angle solution of entry phase (DM), deg
- Type:
numpy.ndarray
- gamma_deg_en
FPA solution of entry phase (DM), deg
- Type:
numpy.ndarray
- drange_km_en
downrange solution of entry phase (DM), km
- Type:
numpy.ndarray
- acc_net_g_en
acceleration solution of entry phase, Earth g
- Type:
numpy.ndarray
- dyn_pres_atm_en
dynamic pressures solution of entry phase, atm
- Type:
numpy.ndarray
- stag_pres_atm_en
stagnation pressure solution of entry phase, atm
- Type:
numpy.ndarray
- q_stag_total_en
heat rate solution of entry phase, W/cm2
- Type:
numpy.ndarray
- heatload_en
heatload solution of entry phase, J/cm2
- Type:
float
- userDefinedCDMach
if set to True, will use a user defined function for CD(Mach) set by setCDMachFunction(), default=False
- Type:
bool
- D(r, theta, phi, v)
Computes the vehicle aerodynamic drag, as a function of the vehicle location(r,theta, phi), and velocity.
- Parameters:
r (float) – radial position value, scalar, m
theta (float) – longitude, radians
phi (float) – latitude, radians
v (float) – planet-relative speed, m/s
- Returns:
ans – aerodynamic drag force, N
- Return type:
float
- Dbar(rbar, theta, phi, vbar)
Computes the non-dimensional vehicle aerodynamic drag, as a function of the vehicle location(r,theta, phi), and velocity.
- Parameters:
rbar (float) – non-dimensional radial position
theta (float) – longitude, radians
phi (float) – latitude, radians
vbar (float) – non-dimensional planet-relative speed, m/s
- Returns:
ans – non-dimensional aerodynamic drag force
- Return type:
float
- Dvectorized(r, theta, phi, v)
Vectorized version of the D() function
Computesthe vehicle aerodynamic drag array over the provided trajectory array, as a function of the vehicle location array (r[:],theta[:], phi[:]), and velocity.
- Parameters:
r (numpy.ndarray) – radial position array, m
theta (numpy.ndarray) – longitude array, radians
phi (numpy.ndarray) – latitude array, radians
v (numpy.ndarray) – planet-relative speed array, m/s
- Returns:
ans – aerodynamic drag force array, N
- Return type:
numpy.ndarray
- EOM(y, t, delta)
Define the EoMs to propogate the 3DoF trajectory inside the atmosphere of a an oblate rotating planet.
Reference 1: Vinh, Chapter 3. Reference 2: Lescynzki, MS Thesis, NPS.
- Parameters:
y (numpy.ndarray) – trajectory state vector
t (numpy.ndarray) – trajectory time vector
delta (float) – bank angle, rad
- Returns:
ans – derivate vector of state, process equations
- Return type:
dydt
- EOM2(t, y, delta)
Define the EoMs to propogate the 3DoF trajectory inside the atmosphere of a an oblate rotating planet.
Reference 1: Vinh, Chapter 3. Reference 2: Lescynzki, MS Thesis, NPS.
- Parameters:
y (numpy.ndarray) – trajectory state vector
t (numpy.ndarray) – trajectory time vector
delta (float) – bank angle, rad
- Returns:
ans – derivate vector of state, process equations
- Return type:
dydt
- L(r, theta, phi, v)
Computes the vehicle aerodynamic lift, as a function of the vehicle location(r,theta, phi), and velocity.
- Parameters:
r (float) – radial position value, scalar, m
theta (float) – longitude, radians
phi (float) – latitude, radians
v (float) – planet-relative speed, m/s
- Returns:
ans – aerodynamic lift force, N
- Return type:
float
- Lbar(rbar, theta, phi, vbar)
Computes the non-dimensional vehicle aerodynamic lift, as a function of the vehicle location(r,theta, phi), and velocity.
- Parameters:
rbar (float) – non-dimensional radial position
theta (float) – longitude, radians
phi (float) – latitude, radians
vbar (float) – non-dimensional planet-relative speed, m/s
- Returns:
ans – non-dimensional aerodynamic lift force
- Return type:
float
- Lvectorized(r, theta, phi, v)
Vectorized version of the L() function
Computesthe vehicle aerodynamic lift array over the provided trajectory array, as a function of the vehicle location array (r[:],theta[:], phi[:]), and velocity.
- Parameters:
r (numpy.ndarray) – radial position array, m
theta (numpy.ndarray) – longitude array, radians
phi (numpy.ndarray) – latitude array, radians
v (numpy.ndarray) – planet-relative speed array, m/s
- Returns:
ans – aerodynamic lift force array, N
- Return type:
numpy.ndarray
- a_n(r, theta, phi, v, delta)
Function to return normal acceleration term a_n;
a_n is the normal acceleration term along perpendicular to the velocity vector, in the plane of the trajectory.
Current formulation does not include thrust, can be added here later in place of 0.0
- Parameters:
r (float) – radial position value, scalar, m
theta (float) – longitude, radians
phi (float) – latitude, radians
v (float) – planet-relative speed, m/s
delta (float) – bank angle, rad
- Returns:
ans – normal acceleration term a_n
- Return type:
float
- a_nbar(rbar, theta, phi, vbar, delta)
Function to return non-dimensional normall acceleration term a_nbar;
a_nbar is the tangential acceleration term along the direction of the velocity vector.
Current formulation does not include thrust, can be added here later in place of 0.0
- Parameters:
rbar (float) – non-dimensional radial position
theta (float) – longitude, radians
phi (float) – latitude, radians
vbar (float) – non-dimensional planet-relative speed, m/s
delta (float) – bank angle, rad
- Returns:
ans – non-dimensional tangential acceleration term a_nbar
- Return type:
float
- a_nvectorized(r, theta, phi, v, delta)
Vectorized version of the a_n() function
- Parameters:
r (numpy.ndarray) – radial position array, m
theta (numpy.ndarray) – longitude array, radians
phi (numpy.ndarray) – latitude array, radians
v (numpy.ndarray) – planet-relative speed array, m/s
delta (float) – bank angle, rad
- Returns:
ans – normal acceleration array, m/s2
- Return type:
numpy.ndarray
- a_s(r, theta, phi, v, delta)
Function to return tangential acceleration term a_s;
a_s is the tangential acceleration term along the direction of the velocity vector.
Current formulation does not include thrust, can be added here later in place of 0.0
- Parameters:
r (float) – radial position value, scalar, m
theta (float) – longitude, radians
phi (float) – latitude, radians
v (float) – planet-relative speed, m/s
delta (float) – bank angle, rad
- Returns:
ans – tangential acceleration term a_s
- Return type:
float
- a_sbar(rbar, theta, phi, vbar, delta)
Function to return non-dimensional tangential acceleration term a_sbar;
a_sbar is the tangential acceleration term along the direction of the velocity vector.
Current formulation does not include thrust, can be added here later in place of 0.0
- Parameters:
rbar (float) – non-dimensional radial position
theta (float) – longitude, radians
phi (float) – latitude, radians
vbar (float) – non-dimensional planet-relative speed, m/s
delta (float) – bank angle, rad
- Returns:
ans – non-dimensional tangential acceleration term a_sbar
- Return type:
float
- a_svectorized(r, theta, phi, v, delta)
Vectorized version of the a_s() function
- Parameters:
r (numpy.ndarray) – radial position array, m
theta (numpy.ndarray) – longitude array, radians
phi (numpy.ndarray) – latitude array, radians
v (numpy.ndarray) – planet-relative speed array, m/s
delta (float) – bank angle, rad
- Returns:
ans – tangential acceleration array, m/s2
- Return type:
numpy.ndarray
- a_w(r, theta, phi, v, delta)
Function to return binormal acceleration term a_w;
a_n is the binormal acceleration term along perpendicular to the velocity vector, perpendicular to the plane of the trajectory.
Current formulation does not include thrust, can be added here later in place of 0.0
- Parameters:
r (float) – radial position value, scalar, m
theta (float) – longitude, radians
phi (float) – latitude, radians
v (float) – planet-relative speed, m/s
delta (float) – bank angle, rad
- Returns:
ans – binormal acceleration term a_n
- Return type:
float
- a_wbar(rbar, theta, phi, vbar, delta)
Function to return non-dimensional normal acceleration term a_wbar;
a_wbar is the tangential acceleration term along the direction of the velocity vector.
Current formulation does not include thrust, can be added here later in place of 0.0
- Parameters:
rbar (float) – non-dimensional radial position
theta (float) – longitude, radians
phi (float) – latitude, radians
vbar (float) – non-dimensional planet-relative speed, m/s
delta (float) – bank angle, rad
- Returns:
ans – non-dimensional tangential acceleration term a_wbar
- Return type:
float
- a_wvectorized(r, theta, phi, v, delta)
Vectorized version of the a_w() function
- Parameters:
r (numpy.ndarray) – radial position array, m
theta (numpy.ndarray) – longitude array, radians
phi (numpy.ndarray) – latitude array, radians
v (numpy.ndarray) – planet-relative speed array, m/s
delta (float) – bank angle, rad
- Returns:
ans – binormal acceleration array, m/s2
- Return type:
numpy.ndarray
- cfgammabar(rbar, phi, vbar, psi, gamma)
Function to return non dimensional centrifugal acceleration term cfgammabar
cfgammabar is the non dimensional centrifugal acceleration term in the EOM
- Parameters:
rbar (float) – non-dimensional radial position
phi (float) – latitude, radians
vbar (float) – non-dimensional planet-relative speed, m/s
psi (float) – heading angle, rad
gamma (float) – flight-path angle, rad
- Returns:
ans – non dimensional centrifugal acceleration cfpsibar
- Return type:
float
- cfpsibar(rbar, phi, vbar, psi, gamma)
Function to return non dimensional centrifugal acceleration term cfpsibar
cfpsibar is the non dimensional centrifugal acceleration term in the EOM
- Parameters:
rbar (float) – non-dimensional radial position
phi (float) – latitude, radians
vbar (float) – non-dimensional planet-relative speed, m/s
psi (float) – heading angle, rad
gamma (float) – flight-path angle, rad
- Returns:
ans – non dimensional centrifugal acceleration cfpsibar
- Return type:
float
- cfvbar(rbar, phi, vbar, psi, gamma)
Function to return non dimensional centrifugal acceleration term cfvbar
cfvbar is the non dimensional centrifugal acceleration term cfvbar in the EOM
- Parameters:
rbar (float) – non-dimensional radial position
phi (float) – latitude, radians
vbar (float) – non-dimensional planet-relative speed, m/s
psi (float) – heading angle, rad
gamma (float) – flight-path angle, rad
- Returns:
ans – non dimensional centrifugal acceleration cfvbar
- Return type:
float
- classifyTrajectory(r)
This function checks the trajectory for “events” which are used to truncate the trajectory
A “skip out event” is said to occur as when the vehicle altitude did not hit the surface and exceeds the prescribed skip out altitude.
A “time out event” is said to occur if the vehicle did not exceed the skip out altitude, and did not reach the trap in altitude.
A “trap in” event is said to occur when the vehicle altitude falls below the prescribed trap in altitude.
This function checks for these events and returns the array index of the “event” location and an exitflag
exitflag to indicate if an event was detected or not. exitflag = 1.0 indicates “skip out event” has occured. exitflag = 0.0 indicates no “event” was detected in the trajectory, consider increasing simulation time. exitflag = -1.0 indicates “trap in event” has occured.
- Parameters:
r (numpy.ndarray) – dimensional radial distance solution, meters
- Returns:
index (int) – array index of the event location if one was detected, terminal index otherwise
exitflag (int) – flag to indicate and classify event occurence or lack of it
- cogammabar(rbar, phi, vbar, psi, gamma)
Function to return non dimensional Coriolis acceleration term cogammabar
- Parameters:
rbar (float) – non-dimensional radial position
phi (float) – latitude, radians
vbar (float) – non-dimensional planet-relative speed, m/s
psi (float) – heading angle, rad
gamma (float) – flight-path angle, rad
- Returns:
ans – non dimensional Coriolis acceleration cogammabar
- Return type:
float
- computeAccelerationDrag(tc, rc, thetac, phic, vc, index, delta)
This function computes the drag acceleration load (Earth G’s) over the entire trajectory from trajectory data returned by the solver.
- Parameters:
tc (numpy.ndarray) – truncated time array, sec
rc (numpy.ndarray) – truncated radial distance array, m
thetac (numpy.ndarray) – truncated longitude array, rad
phic (numpy.ndarray) – trucnated latitude array, rad
vc (numpy.ndarray) – truncated speed array, m
index (int) – array index of detected event location / max index if no event detected
delta (float) – bank angle, rad
- Returns:
acc_drag_g – drag acceleration load (Earth G’s) over the entire trajectory
- Return type:
numpy.ndarray
- computeAccelerationLoad(tc, rc, thetac, phic, vc, index, delta)
This function computes the acceleration load (Earth G’s) over the entire trajectory from trajectory data returned by the solver.
- Parameters:
tc (numpy.ndarray) – truncated time array, sec
rc (numpy.ndarray) – truncated radial distance array, m
thetac (numpy.ndarray) – truncated longitude array, rad
phic (numpy.ndarray) – trucnated latitude array, rad
vc (numpy.ndarray) – truncated speed array, m
index (int) – array index of detected event location / max index if no event detected
delta (float) – bank angle, rad
- Returns:
acc_net_g – acceleration load (Earth G’s) over the entire trajectory
- Return type:
numpy.ndarray
- computeAngMomScalar(terminal_r, terminal_v, terminal_g)
This function computes the specific angular momentum (orbital) of the vehicle at an instance given its current radial distance, speed, and flight-path angle.
- Parameters:
terminal_r (float) – radial distance, meters
terminal_v (float) – speed, meters/sec
terminal_g (float) – flight-path angle, rad
- Returns:
ans – specific angular momentum, SI units
- Return type:
float
- computeDynPres(r, v)
This function computes the dynamic pressure over the entire trajectory.
- Parameters:
r (numpy.ndarray) – radial distance array, m
v (numpy.ndarray) – speed array, m/s
- Returns:
ans – dynamic pressure, Pa
- Return type:
numpy.ndarray
- computeEccScalar(h, E)
This function computes the eccentricity of the orbit given its specific angular momentum, and total specific mechanical energy.
- Parameters:
h (float) – specific angular momentum, SI units
E (float) – specifice energy, J/kg
- Returns:
ans – eccentricity value
- Return type:
float
- computeEnergy(rc, vc)
This function computes the total specific mechanical energy of the vehicle over the entire trajectory.
- Parameters:
rc (numpy.ndarray) – radial distance array, m
vc (numpy.ndarray) – speed array, m/s
- Returns:
ans – specific energy, J/kg
- Return type:
numpy.ndarray
- computeEnergyScalar(r, v)
This function computes the total specific mechanical energy of the vehicle at an instance.
- Parameters:
r (float) – radial distance, m
v (float) – speed array, m/s
- Returns:
ans – specific energy, J/kg
- Return type:
float
- computeHeatingForMultipleRN(tc, rc, vc, rn_array)
This function computes the max. stag. pont heating rate and heat load for an array of nose radii.
- Parameters:
tc (numpy.ndarray) – truncated time array, sec
rc (numpy.ndarray) – truncated radial distance array, m
vc (numpy.ndarray) – speed array, m/s
rn_array (numpy.ndarray) – nose radius array, m
- Returns:
q_stag_max (numpy.ndarray) – max. heat rate, W/cm2
heatload (numpy.ndarray) – max. heatload, J/cm2
- computeMach(rc, vc)
This function computes the Mach. no over the entire trajectory.
- Parameters:
rc (numpy.ndarray) – radial distance array, m
vc (numpy.ndarray) – speed array, m/s
- Returns:
ans – Mach no.
- Return type:
numpy.ndarray
- computeMachScalar(r, v)
This function computes the Mach. no at a single instance.
- Parameters:
r (float) – radial distance, m
v (floar) – speed, m/s
- Returns:
ans – Mach no.
- Return type:
float
- computeSemiMajorAxisScalar(E)
This function computes the semi-major axis of the orbit given its total specific mechanical energy.
- Parameters:
E (float) – specific energy, J/kg
- Returns:
ans – semi major axis, km
- Return type:
float
- computeStagPres(rc, vc)
This function computes the stag. pressure over the entire trajectory.
- Parameters:
rc (numpy.ndarray) – radial distance array, m
vc (numpy.ndarray) – speed array, m/s
- Returns:
ans – stag. pressure, Pa
- Return type:
numpy.ndarray
- computeStagTemp(rc, vc)
This function computes the stag. temperature over the entire trajectory.
- Parameters:
rc (numpy.ndarray) – radial distance array, m
vc (numpy.ndarray) – speed array, m/s
- Returns:
ans – stag. temperature, K
- Return type:
numpy.ndarray
- computeTCW(t_sec, dt, gamma0_deg_guess_low_os, gamma0_deg_guess_high_os, gamma0_deg_guess_low_us, gamma0_deg_guess_high_us, gamma_deg_tol_os, gamma_deg_tol_us, targetApopasisAltitude_km)
Computes the theoretical corridor width (TCW) for lift modulation aerocapture.
TCW = overShootLimit - underShootLimit
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low_os (float) – lower bound for the guess of overshoot limit FPA, deg
gamma0_deg_guess_high_os (float) – upper bound for the guess of overshoot limit FPA, deg
gamma0_deg_guess_low_us (float) – lower bound for the guess of undershoot limit FPA, deg
gamma0_deg_guess_high_us (float) – upper bound for the guess of undershoot limit FPA, deg
gamma_deg_tol_os (float) – desired accuracy for computation of the overshoot limit, deg
gamma_deg_tol_us (float) – desired accuracy for computation of the undershoot limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
TCW – Theoretical Corridor Width, deg
- Return type:
float
- computeTCW2(t_sec, dt, gamma0_deg_guess_low_os, gamma0_deg_guess_high_os, gamma0_deg_guess_low_us, gamma0_deg_guess_high_us, gamma_deg_tol_os, gamma_deg_tol_us, targetApopasisAltitude_km)
Computes the theoretical corridor width (TCW) for lift modulation aerocapture. Includes effect of planet rotation.
TCW = overShootLimit - underShootLimit
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low_os (float) – lower bound for the guess of overshoot limit FPA, deg
gamma0_deg_guess_high_os (float) – upper bound for the guess of overshoot limit FPA, deg
gamma0_deg_guess_low_us (float) – lower bound for the guess of undershoot limit FPA, deg
gamma0_deg_guess_high_us (float) – upper bound for the guess of undershoot limit FPA, deg
gamma_deg_tol_os (float) – desired accuracy for computation of the overshoot limit, deg
gamma_deg_tol_us (float) – desired accuracy for computation of the undershoot limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
TCW – Theoretical Corridor Width, deg
- Return type:
float
- computeTCWD(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
Computes the theoretical corridor width (TCWD) for drag modulation aerocapture. Does not include planet rotation.
TCWD = overShootLimit - underShootLimit
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the EFPA guess, deg
gamma0_deg_guess_high (float) – upper bound for the EFPA guess, deg
gamma_deg_tol (float) – EFPA error tolerance
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
TCWD – Theoretical Corridor Width (Drag Modulation), deg
- Return type:
float
- computeTCWD2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
Computes the theoretical corridor width (TCWD) for drag modulation aerocapture. Includes planet rotation.
TCWD = overShootLimit - underShootLimit
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the EFPA guess, deg
gamma0_deg_guess_high (float) – upper bound for the EFPA guess, deg
gamma_deg_tol (float) – EFPA error tolerance
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
TCWD – Theoretical Corridor Width (Drag Modulation), deg
- Return type:
float
- compute_ApoapsisAltitudeKm(terminal_r, terminal_v, terminal_g, terminal_theta, terminal_phi, terminal_psi)
Compute the apoapsis altitude given conditions at atmospheric exit interface. Note this function includes correction to account for rotation of planet.
Terminal values refer to those at atmospheric exit.
- Parameters:
terminal_r (float) – radial distance, m
terminal_v (float) – terminal speed, m/s
terminal_g (float) – terminal FPA, rad
terminal_theta (float) – terminal longitude, rad
terminal_phi (float) – terminal latitude, rad
terminal_psi (float) – terminal heading angle
- Returns:
hp_km – apoapsis altitude, km
- Return type:
float
- compute_PeriapsisAltitudeKm(terminal_r, terminal_v, terminal_g, terminal_theta, terminal_phi, terminal_psi)
Compute the periapsis altitude given conditions at atmospheric exit interface. Note this function includes correction to account for rotation of planet.
Terminal values refer to those at atmospheric exit.
- Parameters:
terminal_r (float) – radial distance, m
terminal_v (float) – terminal speed, m/s
terminal_g (float) – terminal FPA, rad
terminal_theta (float) – terminal longitude, rad
terminal_phi (float) – terminal latitude, rad
terminal_psi (float) – terminal heading angle
- Returns:
hp_km – periapsis altitude, km
- Return type:
float
- compute_apoapsis_raise_DV(peri_km_current, apo_km_current, apo_km_target)
Compute the propulsive DV to raise the orbit apoapsis to the target value.
- Parameters:
peri_km_current (float) – current periapsis altitude, km
apo_km_current (float) – current apoapsis altitude, km
apo_km_target (float) – target apoapsis altitude, km
- Returns:
dV – apoapsis raise DV, m/s
- Return type:
float
- compute_periapsis_raise_DV(current_peri_km, current_apo_km, target_peri_km)
Compute the propulsive DV to raise the orbit periapsis to the target value.
- Parameters:
current_peri_km (float) – current periapsis altitude, km
current_apo_km (float) – current apoapsis altitude, km
target_peri_km (float) – target periapsis altitude, km
- Returns:
dV – periapse raise DV, m/s
- Return type:
float
- convertToKPa(pres)
Convert a pressure solution array from Pa to kPa.
- Parameters:
pres (numpy.ndarray) – pressure (static/dynamic/total), Pascal (Pa)
- Returns:
ans – pressure (static/dynamic/total), kiloPascal (kPa)
- Return type:
numpy.ndarray
- convertToPerCm2(heatrate)
Convert a heat rate from W/m2 to W/cm2.
- Parameters:
heatrate (numpy.ndarray) – stagnation-point heat rate, W/m2
- Returns:
ans – stagnation-point heat rate, W/cm2
- Return type:
numpy.ndarray
- convertToPlotUnits(t, r, v, phi, psi, theta, gamma, drange)
Convert state vector components to units appropriate for evolution plots.
- Parameters:
t (numpy.ndarray) – time array, sec
r (numpy.ndarray) – radial distance array, m
v (numpy.ndarray) – speed array, m
phi (numpy.ndarray) – latitude array, rad
psi (numpy.ndarray) – heading angle array, rad
theta (numpy.ndarray) – longitude array, rad
gamma (numpy.ndarray) – flight path angle array, rad
drange (numpy.ndarray) – downrange array, meters
- Returns:
t_min (numpy.ndarray) – time array, minutes
h_km (numpy.ndarray) – altitude array, km
v_kms (numpy.ndarray) – speed array, km/s
phi_deg (numpy.ndarray) – latitude array, deg
psi_deg (numpy.ndarray) – heading angle array, deg
theta_deg (numpy.ndarray) – longitude array, deg
gamma_deg (numpy.ndarray) – flight path angle array, deg
drange_km (numpy.ndarray) – downrange array, km
- copsibar(rbar, phi, vbar, psi, gamma)
Function to return non dimensional Coriolis acceleration term copsibar
- Parameters:
rbar (float) – non-dimensional radial position
phi (float) – latitude, radians
vbar (float) – non-dimensional planet-relative speed, m/s
psi (float) – heading angle, rad
gamma (float) – flight-path angle, rad
- Returns:
ans – non dimensional Coriolis acceleration copsibar
- Return type:
float
- createDensityMeasuredFunction(h_step_array, density_mes_array, lowAlt_km, numPoints_lowAlt)
Computes a density function based on measurements made during the descending leg of the aerocapture maneuver.
- Parameters:
h_step_array (numpy.ndarray) – height array at which density is measured, km
density_mes_array (numpy.ndarray) – density array corresponding to h_step_array, kg/m3
lowAlt_km (float) – lower altitude to which density model is to be extrapolated based on available measurements, km
numPoints_lowAlt (int) – number of points to evaluate extrapolation at below the altitude where measurements are available.
- Returns:
density_mes_int (scipy.interpolate.interpolate.interp1d) – interpolated measured density lookup function
minAlt (float) – minimum altitude at which density measurements were available
- createQPlot(t_sec, dt, delta_deg)
Creates q-plots as described by Cerimele and Gamble, 1985.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. solver time step
delta_deg (float) – commanded bank angle, degrees
- Return type:
plt.plot object
- dummyVehicle(density_mes_int)
Create a copy of the vehicle object which uses a measured density profile for propogation.
- Parameters:
density_mes_int (scipy.interpolate.interpolate.interp1d) – density interpolation function
- Returns:
vehicleCopy – dummy vehicle object
- Return type:
vehicle object
- findEFPALimitD(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
This function computes the limiting EFPA for drag modulation aerocapture. Does not include planetary rotation correction.
A bisection algorithm is used to compute the limit.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg
gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg
gamma_deg_tol (float) – desired accuracy for computation of the limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
EFPALimit (float) – limit EFPA, deg
exitflag (float) – flag to indicate if a solution could not be found for the limit EFPA
exitflag = 1.0 indicates over shoot limit was found.
exitflag = 0.0 indicates overshoot limit was not found
within user specified bounds.
- findEFPALimitD2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
This function computes the limiting EFPA for drag modulation aerocapture. Includes planetary rotation correction. Includes planet rotation.
A bisection algorithm is used to compute the limit.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg
gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg
gamma_deg_tol (float) – desired accuracy for computation of the limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
EFPALimit (float) – limit EFPA, deg
exitflag (float) – flag to indicate if a solution could not be found for the limit EFPA
exitflag = 1.0 indicates over shoot limit was found.
exitflag = 0.0 indicates overshoot limit was not found
within user specified bounds.
- findOverShootLimit(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
Computes the overshoot limit entry flight-path angle for aerocapture vehicle using bisection algorithm.
This is shallowest entry flight path angle for which a full lift down trajectory gets the vehicle captured into a post atmospheric exit orbit with the desired target apoapsis altitude.
Note: the overshoot limit entry flight path angle should be computed with an accuracy of at least 10 decimal places to ensure the correct atmospheric trajectory is simulated.
A bisection algorithm is used to compute the overshoot limit.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the guess of overshoot limit FPA, deg
gamma0_deg_guess_high (float) – upper bound for the guess of overshoot limit FPA, deg
gamma_deg_tol (float) – desired accuracy for computation of the overshoot limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
overShootLimit (float) – overshoot limit EFPA, deg
exitflag_os (float) – flag to indicate if a solution could not be found for the overshoot limit
exitflag_os = 1.0 indicates over shoot limit was found.
exitflag_os = 0.0 indicates overshoot limit was not found
within user specified bounds.
- findOverShootLimit2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
Computes the overshoot limit entry flight-path angle for aerocapture vehicle using bisection algorithm. Includes effect of planet rotation on inertial speed.
This is shallowest entry flight path angle for which a full lift down trajectory gets the vehicle captured into a post atmospheric exit orbit with the desired target apoapsis altitude.
Note: the overshoot limit entry flight path angle should be computed with an accuracy of at least 10 decimal places to ensure the correct atmospheric trajectory is simulated.
A bisection algorithm is used to compute the overshoot limit.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the guess of overshoot limit FPA, deg
gamma0_deg_guess_high (float) – upper bound for the guess of overshoot limit FPA, deg
gamma_deg_tol (float) – desired accuracy for computation of the overshoot limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
overShootLimit (float) – overshoot limit EFPA, deg
exitflag_os (float) – flag to indicate if a solution could not be found for the overshoot limit
exitflag_os = 1.0 indicates over shoot limit was found.
exitflag_os = 0.0 indicates overshoot limit was not found
within user specified bounds.
- findOverShootLimitD(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
This function computes the limiting overshoot EFPA for drag modulation aerocapture. Does not include planet rotation.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg
gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg
gamma_deg_tol (float) – desired accuracy for computation of the limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
overShootLimitD (float) – overshoot limit EFPA, deg
exitflagD_os (float) – flag to indicate if a solution could not be found for the overshoot limit EFPA
exitflagD_os = 1.0 indicates over shoot limit was found.
exitflagD_os = 0.0 indicates overshoot limit was not found
within user specified bounds.
- findOverShootLimitD2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
This function computes the limiting overshoot EFPA for drag modulation aerocapture. Includes planet rotation.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg
gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg
gamma_deg_tol (float) – desired accuracy for computation of the limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
overShootLimitD (float) – overshoot limit EFPA, deg
exitflagD_os (float) – flag to indicate if a solution could not be found for the overshoot limit EFPA
exitflagD_os = 1.0 indicates over shoot limit was found.
exitflagD_os = 0.0 indicates overshoot limit was not found
within user specified bounds.
- findUnderShootLimit(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
Computes the undershoot limit entry flight-path angle for aerocapture vehicle using bisection algorithm.
This is steepest entry flight path angle for which a full lift up trajectory gets the vehicle captured into a post atmospheric exit orbit with the desired target apoapsis altitude.
Note: the undershoor limit entry flight path angle should be computed with an accuracy of at least 6 decimal places to ensure the correct atmospheric trajectory is simulated.
A bisection algorithm is used to compute the undershoot limit.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the guess of overshoot limit FPA, deg
gamma0_deg_guess_high (float) – upper bound for the guess of overshoot limit FPA, deg
gamma_deg_tol (float) – desired accuracy for computation of the overshoot limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
underShootLimit (float) – overshoot limit EFPA, deg
exitflag_us (float) – flag to indicate if a solution could not be found for the undershoot limit
exitflag_us = 1.0 indicates undershoot limit was found.
exitflag_us = 0.0 indicates overshoot limit was not found
within user specified bounds.
- findUnderShootLimit2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
Computes the undershoot limit entry flight-path angle for aerocapture vehicle using bisection algorithm. Includes effect of planet rotation on inertial speed.
This is steepest entry flight path angle for which a full lift up trajectory gets the vehicle captured into a post atmospheric exit orbit with the desired target apoapsis altitude.
Note: the undershoor limit entry flight path angle should be computed with an accuracy of at least 6 decimal places to ensure the correct atmospheric trajectory is simulated.
A bisection algorithm is used to compute the undershoot limit.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the guess of overshoot limit FPA, deg
gamma0_deg_guess_high (float) – upper bound for the guess of overshoot limit FPA, deg
gamma_deg_tol (float) – desired accuracy for computation of the overshoot limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
underShootLimit (float) – overshoot limit EFPA, deg
exitflag_us (float) – flag to indicate if a solution could not be found for the undershoot limit
exitflag_us = 1.0 indicates undershoot limit was found.
exitflag_us = 0.0 indicates overshoot limit was not found
within user specified bounds.
- findUnderShootLimitD(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
This function computes the limiting undershoot EFPA for drag modulation aerocapture. Does not include planet rotation.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg
gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg
gamma_deg_tol (float) – desired accuracy for computation of the limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
underShootLimitD (float) – undershoot limit EFPA, deg
exitflagD_us (float) – flag to indicate if a solution could not be found for the undershoot limit EFPA
exitflagD_us = 1.0 indicates undershoot limit was found.
exitflagD_us = 0.0 indicates undershoot limit was not found
within user specified bounds.
- findUnderShootLimitD2(t_sec, dt, gamma0_deg_guess_low, gamma0_deg_guess_high, gamma_deg_tol, targetApopasisAltitude_km)
This function computes the limiting undershoot EFPA for drag modulation aerocapture. Includes planet rotation.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
gamma0_deg_guess_low (float) – lower bound for the guess of limit FPA, deg
gamma0_deg_guess_high (float) – upper bound for the guess of limit FPA, deg
gamma_deg_tol (float) – desired accuracy for computation of the limit, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
underShootLimitD (float) – undershoot limit EFPA, deg
exitflagD_us (float) – flag to indicate if a solution could not be found for the undershoot limit EFPA
exitflagD_us = 1.0 indicates undershoot limit was found.
exitflagD_us = 0.0 indicates undershoot limit was not found
within user specified bounds.
- gnbar(rbar, phi, gamma, psi)
Returns the non-dimensional gravity normal acceleration term gnbar.
- Parameters:
rbar (float) – non-dimensional radial position
phi (float) – latitude, radians
gamma (float) – flight-path angle, rad
psi (float) – heading angle, rad
- Returns:
ans – non-dimensional gravity normal acceleration term gnbar
- Return type:
float
- gphibar(rbar, phi)
Returns the non-dimensional gravity latitudinal acceleration term gphibar.
- Parameters:
rbar (float) – non-dimensional radial position
phi (float) – latitude, radians
- Returns:
ans – non-dimensional gravity latitudinal acceleration term gphibar
- Return type:
float
- grbar(rbar, phi)
Returns the non-dimensional gravity radial acceleration term grbar.
grbar is the non dimensional gravity radial acceleration term grbar in the EOM
- Parameters:
rbar (float) – non-dimensional radial position
phi (float) – latitude, radians
- Returns:
ans – non-dimensional radial acceleration term grbar
- Return type:
float
- gsbar(rbar, phi, gamma, psi)
Returns the non-dimensional gravity tangential acceleration term gsbar.
- Parameters:
rbar (float) – non-dimensional radial position
phi (float) – latitude, radians
gamma (float) – flight-path angle, rad
psi (float) – heading angle, rad
- Returns:
ans – non-dimensional gravity tangential acceleration term gsbar
- Return type:
float
- gthetabar(rbar, phi)
Returns the non-dimensional gravity longitudinal acceleration term.
gthetabar is the non dimensional longitudinal gravity acceleration term grbar in the EOM
- Parameters:
rbar (float) – non-dimensional radial position
phi (float) – latitude, radians
- Returns:
ans – non-dimensional longitudinal gravity acceleration term gthetabar
- Return type:
float
- gwbar(rbar, phi, gamma, psi)
Returns the non-dimensional gravity binormal acceleration term gwbar.
- Parameters:
rbar (float) – non-dimensional radial position
phi (float) – latitude, radians
gamma (float) – flight-path angle, rad
psi (float) – heading angle, rad
- Returns:
ans – non-dimensional gravity binormal acceleration term gwbar
- Return type:
float
- hitsTargetApoapsis(t_sec, dt, delta_deg, targetApopasisAltitude_km)
This function is used to check if the vehicle undershoots or overshoots. Does not include effect of planet rotation to compute inertial speed.
Returns +1 if the vehicle is captured into an orbit with the required target apoapsis alt, -1 otherwise.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
delta_deg (float) – bank angle command, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
ans – -1 indicates overshoot, +1 indicates undershoot
- Return type:
int
- hitsTargetApoapsis2(t_sec, dt, delta_deg, targetApopasisAltitude_km)
This function is used to check if the vehicle undershoots or overshoots. Includes effect of planet rotation to calculate inertial speed.
Returns +1 if the vehicle is captured into an orbit with the required target apoapsis alt, -1 otherwise.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
delta_deg (float) – bank angle command, deg
targetApopasisAltitude_km (float) – target apoapsis altitude , km
- Returns:
ans – -1 indicates overshoot, +1 indicates undershoot
- Return type:
int
- isCaptured(t_sec, dt, delta_deg)
This function determines if the vehicle is captured. Returns -1 if the vehicle is captured, +1 otherwise.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
delta_deg (float) – bank angle command, deg
- Returns:
ans
- Return type:
int
- makeBasicEntryPlots()
This function creates the evolution plots of the altitude, speed, deceleration, and heat rate
- Parameters:
None. –
- Return type:
1 image with 4 subplots
- predictApoapsisAltitudeKm_afterJettision(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)
Compute the apoapsis altitude at exit if the drag skirt is jettisoned at the current vehicle state.
- Parameters:
h0_km (float) – current vehicle altitude, km
theta0_deg (float) – current vehicle longitude, deg
phi0_deg (float) – current vehicle latitude, deg
v0_kms (float) – current vehicle speed, km/s
gamma0_deg (float) – current FPA, deg
psi0_deg (float) – current heading angle, deg
drange0_km (float) – current downrange, km
heatLoad0 (float) – current heatload, J/cm2
t_sec (float) – propogation time, seconds
dt (float) – max. solver timestep
delta_deg (float) – commanded bank angle, deg
density_mes_int (scipy.interpolate.interpolate.interp1d) – measured density interpolation function
- Returns:
terminal_apoapsis_km – apoapsis altitude achieved if drag skirt is jettisoned at the current time, km
- Return type:
float
- predictApoapsisAltitudeKm_afterJettision2(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)
Compute the apoapsis altitude at exit if the drag skirt is jettisoned at the current vehicle state. Uses new solver.
- Parameters:
h0_km (float) – current vehicle altitude, km
theta0_deg (float) – current vehicle longitude, deg
phi0_deg (float) – current vehicle latitude, deg
v0_kms (float) – current vehicle speed, km/s
gamma0_deg (float) – current FPA, deg
psi0_deg (float) – current heading angle, deg
drange0_km (float) – current downrange, km
heatLoad0 (float) – current heatload, J/cm2
t_sec (float) – propogation time, seconds
dt (float) – max. solver timestep
delta_deg (float) – commanded bank angle, deg
density_mes_int (scipy.interpolate.interpolate.interp1d) – measured density interpolation function
- Returns:
terminal_apoapsis_km – apoapsis altitude achieved if drag skirt is jettisoned at the current time, km
- Return type:
float
- predictApoapsisAltitudeKm_withLiftUp(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)
Compute apoapsis altitude using full lift up bank command from current vehicle state till atmospheric exit.
- Parameters:
h0_km (float) – current vehicle altitude, km
theta0_deg (float) – current vehicle longitude, deg
phi0_deg (float) – current vehicle latitude, deg
v0_kms (float) – current vehicle speed, km/s
gamma0_deg (float) – current FPA, deg
psi0_deg (float) – current heading angle, deg
drange0_km (float) – current downrange, km
heatLoad0 (float) – current heatload, J/cm2
t_sec (float) – propogation time, seconds
dt (float) – max. solver timestep
delta_deg (float) – commanded bank angle, deg
density_mes_int (scipy.interpolate.interpolate.interp1d) – measured density interpolation function
- predictApoapsisAltitudeKm_withLiftUp2(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)
Compute apoapsis altitude using full lift up bank command from current vehicle state till atmospheric exit.
- Parameters:
h0_km (float) – current vehicle altitude, km
theta0_deg (float) – current vehicle longitude, deg
phi0_deg (float) – current vehicle latitude, deg
v0_kms (float) – current vehicle speed, km/s
gamma0_deg (float) – current FPA, deg
psi0_deg (float) – current heading angle, deg
drange0_km (float) – current downrange, km
heatLoad0 (float) – current heatload, J/cm2
t_sec (float) – propogation time, seconds
dt (float) – max. solver timestep
delta_deg (float) – commanded bank angle, deg
density_mes_int (scipy.interpolate.interpolate.interp1d) – measured density interpolation function
- propogateEntry(t_sec, dt, delta_deg)
Propogates the vehicle state for a specified time using initial conditions, vehicle properties, and atmospheric profile data.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
delta_deg (float) – bank angle command, deg
- propogateEntry2(t_sec, dt, delta_deg)
Propogates the vehicle state for a specified time using initial conditions, vehicle properties, and atmospheric profile data.
- Parameters:
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
delta_deg (float) – bank angle command, deg
- propogateEntryPhaseD(timeStep, dt, maxTimeSecs)
Implements the entry phase of the guided drag modulation aerocapture (Single-event discrete drag modulation).
The entry phase is defined from the atmospheric entry interface till drag skirt jettison.
- Parameters:
timeStep (float) – Guidance cycle time, seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- propogateEntryPhaseD2(timeStep, dt, maxTimeSecs)
Implements the entry phase of the guided drag modulation aerocapture (Single-event discrete drag modulation).
The entry phase is defined from the atmospheric entry interface till drag skirt jettison.
- Parameters:
timeStep (float) – Guidance cycle time, seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- propogateEntry_util(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)
Utility propogator routine for prediction of atmospheric exit conditions which is then supplied to the apoapis prediction module.
Propogates the vehicle state for using the measured atmospheric profile during the descending leg.
- Parameters:
h0_km (float) – current altitude, km
theta0_deg (float) – current longitude, deg
phi0_deg (float) – current latitude, deg
v0_kms (float) – current speed, km/s
gamma0_deg (float) – current FPA, deg
psi0_deg (float) – current heading angle, deg
drange0_km (float) – current downrange, km
heatLoad0 (float) – current heatload, J/cm2
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
delta_deg (float) – bank angle command, deg
- Returns:
t_minc (numpy.ndarray) – time solution array, min
h_kmc (numpy.ndarray) – altitude solution array, km
v_kmsc (numpy.ndarray) – speed solution array, km/s
phi_degc (numpy.ndarray) – latitude solution array, deg
psi_degc (numpy.ndarray) – heading angle solution array, deg
theta_degc (numpy.ndarray) – longitude solution array, deg
gamma_degc (numpy.ndarray) – FPA solution array, deg
drange_kmc (numpy.ndarray) – downrange solution array, km
exitflag (int) – exitflag
acc_net_g (numpy.ndarray) – acceleration solution array, Earth g
dyn_pres_atm (numpy.ndarray) – dynamic pressure solution array, atm
stag_pres_atm (numpy.ndarray) – stagnation pressure array, atm
q_stag_total (numpy.ndarray) – stagnation point heat rate array
heatload (numpy.ndarray) – stagnation point heat load
acc_drag_g (numpy.ndarray) – acceleration due to drag, Earth g
- propogateEntry_util2(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)
Utility propogator routine for prediction of atmospheric exit conditions which is then supplied to the apoapis prediction module.
Propogates the vehicle state for using the measured atmospheric profile during the descending leg.
- Parameters:
h0_km (float) – current altitude, km
theta0_deg (float) – current longitude, deg
phi0_deg (float) – current latitude, deg
v0_kms (float) – current speed, km/s
gamma0_deg (float) – current FPA, deg
psi0_deg (float) – current heading angle, deg
drange0_km (float) – current downrange, km
heatLoad0 (float) – current heatload, J/cm2
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
delta_deg (float) – bank angle command, deg
- Returns:
t_minc (numpy.ndarray) – time solution array, min
h_kmc (numpy.ndarray) – altitude solution array, km
v_kmsc (numpy.ndarray) – speed solution array, km/s
phi_degc (numpy.ndarray) – latitude solution array, deg
psi_degc (numpy.ndarray) – heading angle solution array, deg
theta_degc (numpy.ndarray) – longitude solution array, deg
gamma_degc (numpy.ndarray) – FPA solution array, deg
drange_kmc (numpy.ndarray) – downrange solution array, km
exitflag (int) – exitflag
acc_net_g (numpy.ndarray) – acceleration solution array, Earth g
dyn_pres_atm (numpy.ndarray) – dynamic pressure solution array, atm
stag_pres_atm (numpy.ndarray) – stagnation pressure array, atm
q_stag_total (numpy.ndarray) – stagnation point heat rate array
heatload (numpy.ndarray) – stagnation point heat load
acc_drag_g (numpy.ndarray) – acceleration due to drag, Earth g
- propogateEntry_utilD(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)
Utility propogator routine for prediction of atmospheric exit conditions which is then supplied to the apoapis prediction module. Does not include planetary rotation.
Propogates the vehicle state for using the measured atmospheric profile during the descending leg.
- Parameters:
h0_km (float) – current altitude, km
theta0_deg (float) – current longitude, deg
phi0_deg (float) – current latitude, deg
v0_kms (float) – current speed, km/s
gamma0_deg (float) – current FPA, deg
psi0_deg (float) – current heading angle, deg
drange0_km (float) – current downrange, km
heatLoad0 (float) – current heatload, J/cm2
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
delta_deg (float) – bank angle command, deg
- Returns:
t_minc (numpy.ndarray) – time solution array, min
h_kmc (numpy.ndarray) – altitude solution array, km
v_kmsc (numpy.ndarray) – speed solution array, km/s
phi_degc (numpy.ndarray) – latitude solution array, deg
psi_degc (numpy.ndarray) – heading angle solution array, deg
theta_degc (numpy.ndarray) – longitude solution array, deg
gamma_degc (numpy.ndarray) – FPA solution array, deg
drange_kmc (numpy.ndarray) – downrange solution array, km
exitflag (int) – exitflag
acc_net_g (numpy.ndarray) – acceleration solution array, Earth g
dyn_pres_atm (numpy.ndarray) – dynamic pressure solution array, atm
stag_pres_atm (numpy.ndarray) – stagnation pressure array, atm
q_stag_total (numpy.ndarray) – stagnation point heat rate array
heatload (numpy.ndarray) – stagnation point heat load
acc_drag_g (numpy.ndarray) – acceleration due to drag, Earth g
- propogateEntry_utilD2(h0_km, theta0_deg, phi0_deg, v0_kms, gamma0_deg, psi0_deg, drange0_km, heatLoad0, t_sec, dt, delta_deg, density_mes_int)
Utility propogator routine for prediction of atmospheric exit conditions which is then supplied to the apoapis prediction module. Includes planetary rotation.
Propogates the vehicle state for using the measured atmospheric profile during the descending leg.
- Parameters:
h0_km (float) – current altitude, km
theta0_deg (float) – current longitude, deg
phi0_deg (float) – current latitude, deg
v0_kms (float) – current speed, km/s
gamma0_deg (float) – current FPA, deg
psi0_deg (float) – current heading angle, deg
drange0_km (float) – current downrange, km
heatLoad0 (float) – current heatload, J/cm2
t_sec (float) – propogation time, seconds
dt (float) – max. time step, seconds
delta_deg (float) – bank angle command, deg
- Returns:
t_minc (numpy.ndarray) – time solution array, min
h_kmc (numpy.ndarray) – altitude solution array, km
v_kmsc (numpy.ndarray) – speed solution array, km/s
phi_degc (numpy.ndarray) – latitude solution array, deg
psi_degc (numpy.ndarray) – heading angle solution array, deg
theta_degc (numpy.ndarray) – longitude solution array, deg
gamma_degc (numpy.ndarray) – FPA solution array, deg
drange_kmc (numpy.ndarray) – downrange solution array, km
exitflag (int) – exitflag
acc_net_g (numpy.ndarray) – acceleration solution array, Earth g
dyn_pres_atm (numpy.ndarray) – dynamic pressure solution array, atm
stag_pres_atm (numpy.ndarray) – stagnation pressure array, atm
q_stag_total (numpy.ndarray) – stagnation point heat rate array
heatload (numpy.ndarray) – stagnation point heat load
acc_drag_g (numpy.ndarray) – acceleration due to drag, Earth g
- propogateEquilibriumGlide(timeStep, dt, maxTimeSecs)
Implements the equilibrium glide phase of the guidance scheme.
- Parameters:
timeStep (float) – Guidance cycle time, seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- propogateEquilibriumGlide2(timeStep, dt, maxTimeSecs)
Implements the equilibrium glide phase of the guidance scheme.
- Parameters:
timeStep (float) – Guidance cycle time, seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- propogateExitPhase(timeStep, dt, maxTimeSecs)
Implements the exit phase of the guidance scheme (full lift-up).
- Parameters:
timeStep (float) – Guidance cycle time, seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- propogateExitPhase2(timeStep, dt, maxTimeSecs)
Implements the exit phase of the guidance scheme (full lift-up).
- Parameters:
timeStep (float) – Guidance cycle time, seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- propogateExitPhaseD(timeStep, dt, maxTimeSecs)
Implements the exit phase of the guidance scheme for drag modulation.
- Parameters:
timeStep (float) – Guidance cycle time, seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- propogateExitPhaseD2(timeStep, dt, maxTimeSecs)
Implements the exit phase of the guidance scheme for drag modulation, with new solver.
- Parameters:
timeStep (float) – Guidance cycle time, seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- propogateGuidedEntry(timeStep, dt, maxTimeSecs)
Implements the full guidance scheme (eq. glide + exit phase)
- Parameters:
timeStep (float) – Guidance cycle time, seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- propogateGuidedEntry2(timeStep, dt, maxTimeSecs)
Implements the full guidance scheme (eq. glide + exit phase)
- Parameters:
timeStep (float) – Guidance cycle time, seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- propogateGuidedEntryD(timeStepEntry, timeStepExit, dt, maxTimeSecs)
Implements the full guidance scheme for drag modulation aerocapture (entry phase + exit phase)
- Parameters:
timeStepEntry (float) – Guidance cycle time (entry phase), seconds
timeStepExit (float) – Guidance cycle time (exit phase), seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- propogateGuidedEntryD2(timeStepEntry, timeStepExit, dt, maxTimeSecs)
Implements the full guidance scheme for drag modulation aerocapture (entry phase + exit phase). Includes inertial correction.
- Parameters:
timeStepEntry (float) – Guidance cycle time (entry phase), seconds
timeStepExit (float) – Guidance cycle time (exit phase), seconds
dt (float) – Solver max. time step, seconds
maxTimeSecs (float) – max. time for propogation, seconds
- psuedoController(DeltaCMD_deg_command, Delta_deg_ini, timestep)
Pseudo controller implenetation for maximum roll rate constraint.
- Parameters:
DeltaCMD_deg_command (float) – commanded bank angle from guidance algorithm, deg
Delta_deg_ini (float) – current vehicle bank angle, deg
maxBankRate (float) – maximum allowed roll rate, deg/s
timestep (float) – guidance cycle timestep
- Returns:
DeltaCMD_deg (float) – actual bank angle response using pseudocontroller, deg
Delta_deg_ini (float) – current bank angle, same as actual bank angle (is redundant)
- qStagConvective(r, v)
This function defines the convective stagnation-point heating relationships. Edit the parameters in the source-code if you wish to modify these values.
Sources : Sutton-Graves relationships, NASA Neptune Orbiter with Probes Vision Report, Bienstock et al.
- Parameters:
r (numpy.ndarray) – radial distance solution array of trajectory, m
v (numpy.ndarray) – planet-relative speed array of trajectory, m/s
- Returns:
ans – convective stagnation-point heating rate array, W/cm2
- Return type:
numpy.ndarray
- qStagRadiative(r, v)
This function defines the radiative stagnation-point heating relationships. Edit the parameters in the source-code if you wish to modify these values.
Radiative heating is currently set to 0 for Mars and Titan, though these may not be negligible under certain conditions.
- Sources :
Craig and Lyne, 2005; Brandis and Johnston, 2014; NASA Vision Neptune orbiter with probes, Contract No. NNH04CC41C
- Parameters:
r (numpy.ndarray) – radial distance solution array of trajectory, m
v (numpy.ndarray) – planet-relative speed array of trajectory, m/s
- Returns:
ans – radiative stagnation-point heating rate array, W/cm2
- Return type:
numpy.ndarray
- qStagTotal(r, v)
Computes the total heat rate which is the sum of the convective and radiative heating rates.
- Parameters:
r (numpy.ndarray) – radial distance solution array of trajectory, m
v (numpy.ndarray) – planet-relative speed array of trajectory, m/s
- Returns:
ans – total stagnation-point heating rate array, W/cm2
- Return type:
numpy.ndarray
- runMonteCarlo(N, mainFolder)
Run a Monte Carlo simulation for lift modulation aerocapture.
- Parameters:
N (int) – Number of trajectories
mainFolder (str) – path where data is to be stored
- runMonteCarlo2(N, mainFolder)
Run a Monte Carlo simulation for lift modulation aerocapture.
- Parameters:
N (int) – Number of trajectories
mainFolder (str) – path where data is to be stored
- runMonteCarloD(N, mainFolder)
Run a Monte Carlo simulation for drag modulation aerocapture.
- Parameters:
N (int) – Number of trajectories
mainFolder (str) – path where data is to be stored
- runMonteCarloD2(N, mainFolder)
Run a Monte Carlo simulation for drag modulation aerocapture with new solver.
- Parameters:
N (int) – Number of trajectories
mainFolder (str) – path where data is to be stored
- runMonteCarloD_Earth(N, mainFolder)
Run a Monte Carlo simulation for drag modulation aerocapture. (Earth application)
- Parameters:
N (int) – Number of trajectories
mainFolder (str) – path where data is to be stored
- setCDMachFunction(func)
Set function for CD (Mach)
- Parameters:
func (function object) – vectorized numpy function which returns CD (Mach) Note: func must return scalar for scalar input, and array for array input!
- setDragEntryPhaseParams(v_switch_kms, lowAlt_km, numPoints_lowAlt, hdot_threshold)
Set entry phase guidance parameters for drag modulation
- Parameters:
v_switch_kms (float) – speed below which entry phase is terminated
lowAlt_km (float) – lower altitude to which density model is to be extrapolated based on available measurements, km
numPoints_lowAlt (int) – number of points to evaluate extrapolation at below the altitude where measurements are available
hdot_threshold (float) – threshold altitude rate (m/s) above which density measurement is terminated and apoapsis prediction is initiated
- setDragModulationVehicleParams(beta1, betaRatio)
Set the beta1 and betaRatio params for a drag modulation vehicle.
- Parameters:
beta1 (float) – small value of ballistic coefficient, kg/m2
betaRatio (float) – ballistic coefficient ratio
- setEquilibriumGlideParams(Ghdot, Gq, v_switch_kms, lowAlt_km, numPoints_lowAlt, hdot_threshold)
Set equilibrium glide phase guidance parameters
- Parameters:
Ghdot (float) – Ghdot term
Gq (float) – Gq term
v_switch_kms (float) – speed below which eq. glide phase is terminated
lowAlt_km (float) – lower altitude to which density model is to be extrapolated based on available measurements, km
numPoints_lowAlt (int) – number of points to evaluate extrapolation at below the altitude where measurements are available
hdot_threshold (float) – threshold altitude rate (m/s) above which density measurement is terminated and apoapsis prediction is initiated
- setInitialState(h0_km, theta0_deg, phi0_deg, v0_kms, psi0_deg, gamma0_deg, drange0_km, heatLoad0)
Set initial vehicle state at atmospheric entry interface
- Parameters:
h0_km (float) – initial vehicle altitude at atmospheric interface / other start point, meters
theta0_deg (float) – initial vehicle longitude at atmospheric interface / other start point, degrees
phi0_deg (float) – initial vehicle latitude at atmospheric interface / other start point, degrees
v0_kms (float) – initial vehicle speed (planet-relative) at atmospheric interface / other start point, km/s
psi0_deg (float) – initial vehicle heading at atmospheric interface / other start point, degrees
gamma0_deg (float) – initial vehicle flight-path angle at atmospheric interface / other start point, degrees
drange0_km (float) – initial vehicle downrange at atmospheric interface / other start point, km
heatLoad0 (float) – initial vehicle heatload at atmospheric interface / other start point, J/cm2
- setMaxRollRate(maxRollRate)
Set the maximum allowed vehicle roll rate (deg/s)
- Parameters:
maxRollRate (float) – maximum roll rate, degrees per second
- setSolverParams(tol)
Set the solver parameters.
- Parameters:
tol (float) – solver tolerance, currently both abstol and reltol are set to this value
- setTargetOrbitParams(target_peri_km, target_apo_km, target_apo_km_tol)
Set the target capture orbit parameters.
- Parameters:
target_peri_km (float) – target periapsis altitude, km
target_apo_km (float) – target apoapsis altitude, km
target_apo_km_tol (float) – target apoapsis altitude error tolerance, km used by guidance algorithm
- setupMonteCarloSimulation(NPOS, NMONTE, atmfiles, heightCol, densLowCol, densAvgCol, densHighCol, densTotalCol, heightInKmFlag, nominalEFPA, EFPA_1sigma_value, nominalLD, LD_1sigma_value, timeStep, dt, maxTimeSecs, atmSigmaFactor=1)
Set the Monte Carlo simulation parameters.
- Parameters:
NPOS (int) – NPOS value from GRAM model output is the number of data points (altitude) in each atm. profile
NMONTE (int) – NMONTE is the number of Monte Carlo atm profiles from GRAM model output
atmfiles (str) – location of atmospheric files used in Monte Carlo simulation
heightCol (int) – column index of height values in atmfiles
densLowCol (int) – column index of low density (-1 sigma) values in atmfiles
densAvgCol (int) – column index of average density values in atmfiles
densHighCol (int) – column index of high density values (+1 sigma) in atmfiles
densTotalCol (int) – index of perturbed (=avg + pert.) density values
heightInKmFlag (bool) – set to True if height values in atmfiles are in km
nominalEFPA (float) – Nominal (target EFPA) value, deg
EFPA_1sigma_value (float) – 1-sigma error for EFPA (from naviation analysis)
nominalLD (float) – Nominal value of vehicle L/D
LD_1sigma_value (float) – 1-sigma error for L/D (from vehicle aero. design data)
timeStep (float) – Guidance cycle time step, sec
dt (float) – max. solver time step
maxTimeSecs (float) – max. time used for propogation used by guidance scheme
- setupMonteCarloSimulationD(NPOS, NMONTE, atmfiles, heightCol, densLowCol, densAvgCol, densHighCol, densTotalCol, heightInKmFlag, nominalEFPA, EFPA_1sigma_value, nominalbeta1, beta1_1sigma_value, timeStepEntry, timeStepExit, dt, maxTimeSecs)
Set the Monte Carlo simulation parameters for drag modulation aerocapture.
- Parameters:
NPOS (int) – NPOS value from GRAM model output is the number of data points (altitude) in each atm. profile
NMONTE (int) – NMONTE is the number of Monte Carlo atm profiles from GRAM model output
atmfiles (str) – location of atmospheric files used in Monte Carlo simulation
heightCol (int) – column index of height values in atmfiles
densLowCol (int) – column index of low density (-1 sigma) values in atmfiles
densAvgCol (int) – column index of average density values in atmfiles
densHighCol (int) – column index of high density values (+1 sigma) in atmfiles
densTotalCol (int) – index of perturbed (=avg + pert.) density values
heightInKmFlag (bool) – set to True if height values in atmfiles are in km
nominalEFPA (float) – Nominal (target EFPA) value, deg
EFPA_1sigma_value (float) – 1-sigma error for EFPA (from naviation analysis)
nominalbeta1 (float) – Nominal value of vehicle ballistic coeff.
beta1_1sigma_value (float) – 1-sigma error for beta1 (from vehicle aero. design data)
timeStepEntry (float) – Guidance cycle time step for entry phase, sec
timeStepExit (float) – Guidance time step for exit phase, sec
dt (float) – max. solver time step
maxTimeSecs (float) – max. time used for propogation used by guidance scheme
- setupMonteCarloSimulationD_Earth(NPOS, NMONTE, atmfiles, heightCol, densAvgCol, densSD_percCol, densTotalCol, heightInKmFlag, nominalEFPA, EFPA_1sigma_value, nominalbeta1, beta1_1sigma_value, timeStepEntry, timeStepExit, dt, maxTimeSecs)
Set the Monte Carlo simulation parameters for drag modulation aerocapture. (Earth aerocapture)
- Parameters:
NPOS (int) – NPOS value from GRAM model output is the number of data points (altitude) in each atm. profile
NMONTE (int) – NMONTE is the number of Monte Carlo atm profiles from GRAM model output
atmfiles (str) – location of atmospheric files used in Monte Carlo simulation
heightCol (int) – column index of height values in atmfiles
densAvgCol (int) – column index of average density values in atmfiles
densSD_percCol (int) – column number of mean density one sigma SD
densTotalCol (int) – index of perturbed (=avg + pert.) density values
heightInKmFlag (bool) – set to True if height values in atmfiles are in km
nominalEFPA (float) – Nominal (target EFPA) value, deg
EFPA_1sigma_value (float) – 1-sigma error for EFPA (from naviation analysis)
nominalbeta1 (float) – Nominal value of vehicle ballistic coeff.
beta1_1sigma_value (float) – 1-sigma error for beta1 (from vehicle aero. design data)
timeStepEntry (float) – Guidance cycle time step for entry phase, sec
timeStepExit (float) – Guidance time step for exit phase, sec
dt (float) – max. solver time step
maxTimeSecs (float) – max. time used for propogation used by guidance scheme
- solveTrajectory(rbar0, theta0, phi0, vbar0, psi0, gamma0, drangebar0, t_sec, dt, delta)
Function to propogate a single atmospheric entry trajectory given entry interface / other initial conditions and bank angle delta.
Reference 1: Vinh, Chapter 3. Reference 2: Lescynzki, MS Thesis, NPS.
- Parameters:
rbar0 (float) – non-dimensional radial distance initial condition
theta0 (float) – longitude initial condition, rad
phi0 (float) – latatitude initial condition, rad
vbar0 (float) – non-dimensional planet-relative speed initial condition
psi0 (float) – heading angle initial condition, rad
gamma0 (float) – entry flight-path angle initial condition, rad
drangebar0 (float) – non-dimensional downrange initial condition
t_sec (float) – time in seconds for which propogation is done
dt (float) – max. time step size in seconds
delta (float) – bank angle command, rad
- Returns:
tbar (numpy.ndarray) – nondimensional time at which solution is computed
rbar (numpy.ndarray) – nondimensional radial distance solution
theta (numpy.ndarray) – longitude solution, rad
phi (numpy.ndarray) – latitude array, rad
vbar (numpy.ndarray) – nondimensional velocity solution
psi (numpy.ndarray, rad) – heading angle solution, rad
gamma (numpy.ndarray) – flight-path angle, rad
drangebar (numpy.ndarray) – downrange solution, meters
- solveTrajectory2(rbar0, theta0, phi0, vbar0, psi0, gamma0, drangebar0, t_sec, dt, delta)
Function to propogate a single atmospheric entry trajectory given entry interface / other initial conditions and bank angle delta.
Reference 1: Vinh, Chapter 3. Reference 2: Lescynzki, MS Thesis, NPS.
- Parameters:
rbar0 (float) – non-dimensional radial distance initial condition
theta0 (float) – longitude initial condition, rad
phi0 (float) – latatitude initial condition, rad
vbar0 (float) – non-dimensional planet-relative speed initial condition
psi0 (float) – heading angle initial condition, rad
gamma0 (float) – entry flight-path angle initial condition, rad
drangebar0 (float) – non-dimensional downrange initial condition
t_sec (float) – time in seconds for which propogation is done
dt (float) – max. time step size in seconds
delta (float) – bank angle command, rad
- Returns:
tbar (numpy.ndarray) – nondimensional time at which solution is computed
rbar (numpy.ndarray) – nondimensional radial distance solution
theta (numpy.ndarray) – longitude solution, rad
phi (numpy.ndarray) – latitude array, rad
vbar (numpy.ndarray) – nondimensional velocity solution
psi (numpy.ndarray, rad) – heading angle solution, rad
gamma (numpy.ndarray) – flight-path angle, rad
drangebar (numpy.ndarray) – downrange solution, meters
- truncateTrajectory(t, r, theta, phi, v, psi, gamma, drange, index)
This function truncates the full trajectory returned by the solver to the first event location.
The full trajectory returned by the solver could have skipped out exceeding the skip out altitude, or could have descended below the trap in altitude or even below the surface.
This function helps ensure that we truncate the trajectory to what we actually need, i.e. till a skip out / trap in event.
- Parameters:
t (numpy.ndarray) – time array, sec
r (numpy.ndarray) – radial distance array, m
v (numpy.ndarray) – speed array, m
phi (numpy.ndarray) – latitude array, rad
psi (numpy.ndarray) – heading angle array, rad
theta (numpy.ndarray) – longitude array, rad
gamma (numpy.ndarray) – flight path angle array, rad
drange (numpy.ndarray) – downrange array, meters
index (int) – array index of detected event location / max index if no event detected
- Returns:
t (numpy.ndarray) – truncated time array, sec
r (numpy.ndarray) – truncated radial distance array, m
v (numpy.ndarray) – truncated speed array, m
phi (numpy.ndarray) – truncated latitude array, rad
psi (numpy.ndarray) – truncated heading angle array, rad
theta (numpy.ndarray) – truncated longitude array, rad
gamma (numpy.ndarray) – truncated flight path angle array, rad
drange (numpy.ndarray) – truncated downrange array, meters
- class AMAT.approach.Approach(arrivalPlanet, v_inf_vec_icrf_kms, rp, psi, is_entrySystem=False, h_EI=None)
Compute the probe/spacecraft approach trajectory for a given v_inf_vec, periapsis radius, psi.
REF: Hughes (2016), Ph.D. Dissertation, Purdue University
- planetObj
arrival planet object for approach traje
- Type:
AMAT.planet.Planet object
- a
semi-major axis, meters
- Type:
float
- e
eccentricity
- Type:
float
- beta
true anomaly of the outgoing asymptote, rad
- Type:
float
- v_inf_vec_bi_kms
v_inf vector in body-inertial frame, km/s
- Type:
numpy.ndarray
- v_inf_vec_bi
v_inf vector in body-inertial frame, m/s
- Type:
numpy.ndarray
- v_inf_vec_bi_mag_kms
v_inf magnitude in body-inertial frame, km/s
- Type:
float
- phi_1
rad, as defined in Eq. (2.16) from REF.
- Type:
float
- phi_2
rad, as defined in Eq. (2.17) from REF.
- Type:
float
- rp_vec_bi_unit
periapsis radius unit vector in body-inertial frame
- Type:
numpy.ndarray
- rp_vec_bi
periapsis radius vector in body-inertial frame, meters
- Type:
numpy.ndarray
- e_vec_bi_unit
eccentricity unit vector in body-inertial frame
- Type:
numpy.ndarray
- e_vec_bi
eccentricity vector in body-inertial frame, meters
- Type:
numpy.ndarray
- h
angular momentum, SI units
- Type:
float
- h_vec_bi
angular momentum vector in body-inertial frame, SI units
- Type:
numpy.ndarray
- h_vec_bi_unit
angular momentum unit vector in body-inertial frame, SI units
- Type:
numpy.ndarray
- i
inclination [0, np.pi], rad
- Type:
float
- N_vec_bi
node vector in body-inertial frame
- Type:
numpy.ndarray
- N_vec_bi_unit
node unit vector in body-inertial frame
- Type:
numpy.ndarray
- OMEGA
right asecension of ascending node, rad
- Type:
float
- omega
argument of periapsis, rad
- Type:
float
- N_ref_bi
reference normal vector in body-inertial frame (planet’s spin axis)
- Type:
numpy.ndarray
- S_vec_bi
S vector in body-inertial frame, meters
- Type:
numpy.ndarray
- S_vec_bi_unit
S unit vector in body-inertial frame, meters
- Type:
numpy.ndarray
- T_vec_bi
T vector in body-inertial frame, meters
- Type:
numpy.ndarray
- T_vec_bi_unit
T unit vector in body-inertial frame, meters
- Type:
numpy.ndarray
- R_vec_bi
R vector in body-inertial frame, meters
- Type:
numpy.ndarray
- R_vec_bi_unit
R unit vector in body-inertial frame, meters
- Type:
numpy.ndarray
- B_vec_bi
B vector in body-inertial frame, meters
- Type:
numpy.ndarray
- B_vec_bi_unit
B unit vector in body-inertial frame, meters
- Type:
numpy.ndarray
- b_mag
aim point vector B magnitude, meters
- Type:
float
- b_plane_angle_theta
angle between aim point vector B and T
- Type:
float
- r_EI
atmospheric entry interface radius, m
- Type:
float
- theta_star_entry
true anomaly at entry interface, rad
- Type:
float
- r_vec_entry_bi
position vector at entry interface in body-inertial frame, meters
- Type:
numpy.ndarray
- r_vec_entry_bi_unit
position unit vector at entry interface in body-inertial frame, meters
- Type:
numpy.ndarray
- r_vec_entry_bi_mag
position vector magnitude at entry interface in body-inertial frame, meters
- Type:
float
- v_entry_inertial_mag
inertial velocity magnitude at entry interface in body-inertial frame, m/s
- Type:
float
- gamma_entry_inertial
inertial flight path angle at entry interface, rad
- Type:
float
- v_vec_entry_bi
inertial velocity vector at entry interface in body-inertial frame, m/s
- Type:
numpy.ndarray
- v_vec_entry_bi_unit
inertial velocity unit vector at entry interface in body-inertial frame, m/s
- Type:
numpy.ndarray
- gamma_entry_inertial_check
analytic solution for inertial flight path angle at entry interface, rad
- Type:
float
- latitude_entry_bi
entry latitude in body-inertial frame, rad
- Type:
float
- longitude_entry_bi
entry longitude in body-inertial frame, rad
- Type:
float
- v_vec_entry_atm
atmosphere-relative velocity vector at entry interface in body-inertial frame, m/s
- Type:
numpy.ndarray
- v_entry_atm_mag
atmosphere-relative velocity magnitude at entry interface in body-inertial frame, m/s
- Type:
float
- v_vec_entry_atm_unit
atmosphere-relative velocity unit vector at entry interface in body-inertial frame, m/s
- Type:
numpy.ndarray
- gamma_entry_atm
atmosphere-relative flight path angle at entry interface, rad
- Type:
float
- v_vec_entry_atm_unit_proj
projection of atmosphere-relative vector onto local horizontal plane at entry interface in body-inertial frame
- Type:
numpy.ndarray
- local_latitude_parallel_vec_unit
unit vector direction of local parallel of latitude at entry interface in body-inertia frame
- Type:
numpy.ndarray
- heading_entry_atm
atmosphere-relative heading angle at entry interface, rad
- Type:
float
- BI_to_BI_dprime(X_ICRF)
Converts an input vector from body-inertial to body-inertial-double-prime frame following Eq. (2.10) of REF.
- Parameters:
X_ICRF (numpy.ndarray) – row vector in body-inertial frame
- Returns:
ans – input vector in body-inertial double-prime frame
- Return type:
numpy.ndarray
- ICRF_to_BI(X_ICRF)
Converts an input vector from ICRF to body-inertial frame
- Parameters:
X_ICRF (numpy.ndarray) – row vector in ICRF frame
- Returns:
ans – input vector in body-inertial frame
- Return type:
numpy.ndarray
- R1(theta)
Direction cosine matrix for rotation about x-axis.
- Parameters:
theta (float) – rotation angle about x-axis
- Returns:
ans – Direction cosine matrix for rotation about x-axis.
- Return type:
numpy.ndarray
- R2(theta)
Direction cosine matrix for rotation about y-axis.
- Parameters:
theta (float) – rotation angle about y-axis
- Returns:
ans – Direction cosine matrix for rotation about y-axis.
- Return type:
numpy.ndarray
- R3(theta)
Direction cosine matrix for rotation about z-axis.
- Parameters:
theta (float) – rotation angle about zaxis
- Returns:
ans – Direction cosine matrix for rotation about z-axis.
- Return type:
numpy.ndarray
- pos_vec_bi(theta_star)
Computes the position vector in body-inertial frame for a specified true-anomaly.
- Parameters:
theta_star (float) – true anomaly, rad
- Returns:
pos_vec_bi – position vector in body-inertial frame, meters
- Return type:
numpy.ndarray
- pos_vec_bi_dprime(theta_star)
Computes the position vector in body-inertial double-prime frame for a specified true-anomaly.
- Parameters:
theta_star (float) – true anomaly, rad
- Returns:
pos_vec_bi_dprime – position vector in body-inertial double-prime frame, meters
- Return type:
numpy.ndarray
- r_mag_bi(theta_star)
Computes the position vector magnitude in body-inertial frame at a given true anomaly.
- Parameters:
theta_star (float) – true anomaly, rad
- Returns:
r_mag_bi – position vector magnitude, meters
- Return type:
float
- vel_vec_bi(theta_star)
Computes the velocity vector magnitude in body-inertial frame at a given true anomaly.
- Parameters:
theta_star (float) – true anomaly, rad
- Returns:
vel_vec_bi – velocity vector in body-inertial frame, m/s
- Return type:
numpy.ndarray
- vel_vec_entry_atm()
Computes the atmosphere-relative velocity vector magnitude in body-inertial frame at atmospheric entry interface.
- Returns:
vel_vec_entry_atm – atmosphere-relative velocity vector in body-inertial frame, at atmospheric entry interface, m/s
- Return type:
numpy.ndarray
- class AMAT.interplanetary.Interplanetary(ID, datafile, sheet_name, Lcdate_format)
Stores a dataframe containing interplanetary data from an external source.
- ID
string identifier for the interplanetary dataset
- Type:
str
- datafile
Excel file containing interplanetary trajectory data
- Type:
filepath
- sheet_name
Sheet name containing trajectory data
- Type:
str
- df
dataframe containing the interplanetary trajectory data
- Type:
pandas.DataFrame object
- Lcdate
Series containing launch date datetime objects
- Type:
pandas.Series
- C3
Series containing launch C3
- Type:
pandas.Series
- TOF
Series containing time of flight, years
- Type:
pandas.Series
- Avinf
Series containing arrival vinf magnitude, km/s
- Type:
pandas.Series
- compute_launch_capability(launcherObj)
- Parameters:
launcherObj (AMAT.launcher.Launcher object) –
- Returns:
ans – array containing the launch mass capability for C3 values in the trajectory dataset
- Return type:
numpy.ndarray
- plot_Avinf_vs_launch_date()
Scatter plot of the arrival vinf magnitude as a function of launch date.
- Returns:
ans – Scatter of the arrival vinf magnitude as a function of launch date
- Return type:
matplotlib.figure.Figure
- plot_Avinf_vs_launch_date_with_launch_mass_colorbar(launcherObj, scale=20)
Scatter plot of the arrival vinf magnitude as a function of launch date with launch capability colorbar.
- Parameters:
launcherObj (AMAT.launcher.Launcher object) – AMAT Launcher object
scale (float) – scatter plot marker size, defaults to 20
- Returns:
ans – Scatter of the arrival vinf magnitude as a function of launch date with launch capability colorbar.
- Return type:
matplotlib.figure.Figure
- plot_TOF_vs_launch_date()
Scatter plot of the time of flight as a function of launch date.
- Returns:
ans – Scatter of the launch capability as a function of launch date
- Return type:
matplotlib.figure.Figure
- plot_launch_mass_vs_TOF(launcherObj)
Scatter plot of the launch mass as a function of TOF.
- Returns:
ans – Scatter plot of the launch mass as a function of TOF.
- Return type:
matplotlib.figure.Figure
- plot_launch_mass_vs_TOF_with_vinf_colorbar(launcherObj, scale=20)
Scatter plot of the launch mass as a function of TOF with arrival vinf colorbar.
- Parameters:
launcherObj (AMAT.launcher.Launcher object) – AMAT Launcher object
scale (float) – scatter plot marker size, defaults to 20
- Returns:
ans – Scatter plot of the launch mass as a function of TOF with arrival vinf colorbar.
- Return type:
matplotlib.figure.Figure
- plot_launch_mass_vs_launch_date(launcherObj)
Scatter plot of the launch capability as a function of launch date.
- Parameters:
launcherObj (AMAT.launcher.Launcher object) – AMAT Launcher object
- Returns:
ans – Scatter of the launch capability as a function of launch date
- Return type:
matplotlib.figure.Figure
- class AMAT.launcher.Launcher(launcherID, datafile, kind='linear')
The Launcher class is used to estimate launch vehicle performance.
- launcherID
String identifier for launch vehicle
- Type:
str
- datafile
CSV file containing C3,launch mass (kg)
- Type:
CSV file
- kind
type of interpolation to use. Defaults to ‘linear’
- Type:
str
- f
interpolation function for launch mass at a specified C3
- Type:
scipy.interpolate.interp1d
- launchMass(C3)
Returns the launch capability of the vehicle for a specified C3 array.
- Parameters:
C3 (float) – launch C3, km2/s2
- Returns:
mass – launch mass capability, kg
- Return type:
float
- class AMAT.maneuver.OrbiterOrbiterDeflection(arrivalPlanet, v_inf_vec_icrf_kms, rp_space1, psi_space1, rp_space2, psi_space2, r_dv_rp)
Computes the deflection maneuver delta-V and time of flight for delivering two orbiter spacecraft from an approach trajectory.
- planetObj
arrival planet object for approach trajectory
- Type:
AMAT.planet.Planet object
- space1
Approach object with approach trajectory parameters for the first orbiter spacecraft
- Type:
AMAT.approach.Approach object
- space2
Approach object with approach trajectory parameters for the second orbiter spacecraft
- Type:
AMAT.approach.Approach object
- r_dv_rp
radial distance at which the deflection maneuver is performed, in terms of arrival planet radius Example: 1000, for maneuver performed at radial distance of 1000 times the radius of the planet.
- Type:
float
- r_dv
radial distance at which the deflection maneuver is performed, in meters
- Type:
float
- theta_star_dv_space1
true anomaly of the first orbiter spacecraft at deflection maneuver, rad
- Type:
float
- r_vec_dv
position vector at deflection maneuver in body-inertial frame, meters
- Type:
numpy.ndarray
- r_vec_dv_unit
position unit vector at deflection maneuver in body-inertial frame
- Type:
numpy.ndarray
- delta_theta_star_space1
true anomaly change for first orbiter spacecraft (Eq. 2.78, REF), rad
- Type:
float
- delta_theta_star_space2
true anomaly change for second orbiter spacecraft (Eq. 2.78, REF), rad
- Type:
float
- v_vec_dv_space1
first orbiter spacecraft velocity vector in body-inertial frame, meters
- Type:
numpy.ndarray
- v_vec_dv_space2
second orbiter spacecraft velocity vector in body-inertial frame, meters
- Type:
numpy.ndarray
- v_vec_dv_maneuver
deflection maneuver delta-V vector, m/s
- Type:
numpy.ndarray
- v_vec_dv_maneuver_mag
deflection maneuver delta-V magnitude, m/s
- Type:
numpy.ndarray
- TOF_space1
first spacecraft orbiter time of flight from deflection maneuver until periapsis, days
- Type:
float
- TOF_space2
second spacecraft orbiter time of flight from deflection maneuver until periapsis, days
- Type:
float
- class AMAT.maneuver.ProbeOrbiterDeflection(arrivalPlanet, v_inf_vec_icrf_kms, rp_probe, psi_probe, h_EI_probe, rp_space, psi_space, r_dv_rp)
Computes the deflection manuever delta-V and time of flight for an orbiter spacecraft divert manuever for propulsive orbit insertion after probe release on approach.
- planetObj
arrival planet object for approach trajectory
- Type:
AMAT.planet.Planet object
- probe
Approach object with approach trajectory parameters for the entry probe
- Type:
AMAT.approach.Approach object
- space
Approach object with approach trajectory parameters for the orbiter spacecraft
- Type:
AMAT.approach.Approach object
- r_dv_rp
radial distance at which the deflection maneuver is performed, in terms of arrival planet radius Example: 1000, for maneuver performed at radial distance of 1000 times the radius of the planet.
- Type:
float
- r_dv
radial distance at which the deflection maneuver is performed, in meters
- Type:
float
- theta_star_dv_probe
true anomaly of the probe at deflection maneuver, rad
- Type:
float
- r_vec_dv
probe position vector at maneuver in body-inertial frame, meters
- Type:
numpy.ndarray
- r_vec_dv_unit
probe position unit vector at maneuver in body-inertial frame
- Type:
numpy.ndarray
- delta_theta_star_probe
true anomaly change for probe (Eq. 2.75, REF), rad
- Type:
float
- delta_theta_star_space
true anomaly change for orbiter (Eq. 2.78, REF), rad
- Type:
float
- v_vec_dv_probe
probe velocity vector in body-inertial frame, meters
- Type:
numpy.ndarray
- v_vec_dv_space
orbiter velocity vector in body-inertial frame, meters
- Type:
numpy.ndarray
- v_vec_dv_maneuver
orbiter deflection maneuver delta-V vector, m/s
- Type:
numpy.ndarray
- v_vec_dv_maneuver_mag
orbiter deflection maneuver delta-V magnitude, m/s
- Type:
numpy.ndarray
- TOF_probe
probe time of flight from deflection maneuver until atmospheric entry interface, days
- Type:
float
- TOF_space
orbiter time of flight from deflection maneuver until periapsis, days
- Type:
float
- class AMAT.maneuver.ProbeProbeDeflection(arrivalPlanet, v_inf_vec_icrf_kms, rp_probe1, psi_probe1, h_EI_probe1, rp_probe2, psi_probe2, h_EI_probe2, r_dv_rp)
Computes the deflection maneuver delta-V and time of flight for delivering two atmospheric entry systems from an approach trajectory.
- planetObj
arrival planet object for approach trajectory
- Type:
AMAT.planet.Planet object
- probe1
Approach object with approach trajectory parameters for the first entry probe
- Type:
AMAT.approach.Approach object
- probe2
Approach object with approach trajectory parameters for the second entry probe
- Type:
AMAT.approach.Approach object
- r_dv_rp
radial distance at which the deflection maneuver is performed, in terms of arrival planet radius Example: 1000, for maneuver performed at radial distance of 1000 times the radius of the planet.
- Type:
float
- r_dv
radial distance at which the deflection maneuver is performed, in meters
- Type:
float
- theta_star_dv_probe1
true anomaly of the first probe at deflection maneuver, rad
- Type:
float
- theta_star_dv_probe2
true anomaly of the second probe at deflection maneuver, rad
- Type:
float
- delta_theta_star_probe1
true anomaly change for first probe (Eq. 2.75, REF), rad
- Type:
float
- delta_theta_star_probe2
true anomaly change for second probe (Eq. 2.75, REF), rad
- Type:
float
- v_vec_dv_probe1
first probe velocity vector in body-inertial frame, meters
- Type:
numpy.ndarray
- v_vec_dv_probe2
second probe velocity vector in body-inertial frame, meters
- Type:
numpy.ndarray
- v_vec_dv_maneuver
deflection maneuver delta-V vector, m/s
- Type:
numpy.ndarray
- v_vec_dv_maneuver_mag
deflection maneuver delta-V magnitude, m/s
- Type:
numpy.ndarray
- TOF_probe1
probe time of flight from deflection maneuver until atmospheric entry interface, days
- Type:
float
- TOF_probe2
orbiter time of flight from deflection maneuver until atmospheric entry interface, days
- Type:
float
- class AMAT.orbiter.Orbiter(vehicle, peri_alt_km)
Compute the coast trajectory from atmospheric exit until apoapsis, the periapsis raise manuever dv, and the first full orbit post aerocapture. Also computes the probe trajectory following a probe-targeting maneuver, probe atmospheric entry conditions, and the orbiter trajectory following an orbiter deflection manuever.
- vehicle
Vehicle object which has been propagated until atmospheric exit
- Type:
- 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:
- 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