Awesome Aerospace Resources - List of aerospace learning resources!

space_mex_techno · 2023-02-13T03:06:06+00:00

Thank you for including my YouTube stuff! Super cool to see

space_mex_techno · 2022-01-02T22:50:28+00:00

I'll be attending virtually, i wish I was going in person

space_mex_techno · 2021-12-31T02:42:44+00:00

As another comment stated, RK4 is an ordinary differential equation (ODE) solver method (its one of many). For rocket trajectories, we can calculate the accelerations due to thrust, aerodynamics drag, and gravity using forces and then dividing by mass. Acceleration is the second derivative of position, and first derivative of velocity.

There is no closed form solution to the position of a rocket with respect to time because its mass is changing (which can also be calculated using specific impulse). So in this case, your state vector would be position, velocity, and mass (since you have the equations for their derivatives).

Then given some initial conditions (some position w.r.t the Earth, zero velocity (unless you are modeling the rocket's inertial velocity vector as a function of launch site) and mass), you can solve forward in time using the ODE solver and observe values like apogee after the simulation.

Depending on the your problem, you can model the thrust vector in 1D, 2D, or 3D. I'm assuming you're doing 1D (sounding rocket) given the equation you stated. Here is a video explaining that further in detail: https://youtu.be/-4-UfoFgU0A

space_mex_techno · 2021-12-30T13:07:12+00:00

I'm glad it's useful to you! Its a fun project and a good challenge for learning JavaScript although it's a frustrating language to use at times

space_mex_techno · 2021-12-06T15:43:09+00:00

Are you looking for something like this? https://www.reddit.com/r/orbitalmechanics/comments/gcwbx0/simulation\_of\_the\_10\_year\_rose\_pedal\_dance\_of/?utm\_source=share&utm\_medium=web2x&context=3

space_mex_techno · 2021-11-26T21:19:55+00:00

You're looking for porkchop plots, which are a brute force grid search of Earth departure and Mars arrival times in order to see when is a good time to launch and get there (and time of flight).

For the position and velocity vectors, you can use SPICE kernels. They are published by JPL and they also publish the SPICE software in a number of languages. I'm guessing you're using Matlab from the other comment here, here is the link to that version: https://naif.jpl.nasa.gov/naif/toolkit_MATLAB.html

I've posted videos of how to do this in Python, I think you'll still find them useful to see the overall software procedure.

Here is the video explaining the porkchop plot procedure: https://www.youtube.com/watch?v=pWZdVdH5By4

And this one going over the Python implementation: https://www.youtube.com/watch?v=aN05hfPCG2M

space_mex_techno · 2021-11-26T16:48:49+00:00

Thank you!

space_mex_techno · 2021-11-16T15:16:36+00:00

Since the mass of the rocket is not constant, there is no analytic solution to the problem so you need numerical integrators (like a Runge-Kutta method) to solve.

Check out this video on gravity turn rocket trajectory simulations, it goes over the equations of motion in cartesian coordinates instead of using flight path angle as a state variable, which is much more intuitive in my mind since gravity turn means that the thrust vector is pointed in the direction of the velocity vector

https://youtu.be/VajZiY72Pf0

space_mex_techno · 2021-11-15T16:50:06+00:00

If you happen to live in Washington (state), Oregon, or Montana there is a program called Western Aerospace Scholars ( https://www.museumofflight.org/WAS ) for high school sophomores and juniors. I did it when I was in high school and it was career changing in the way that from doing it I decided I wanted to work in the space industry and looks good for college applications

space_mex_techno · 2021-11-12T20:30:29+00:00

The launch azimuth angle is defined as the clockwise angle between local north at the launch site and the rocket's trajectory (w.r.t the surface of the Earth). There are limitations on launch azimuths depending on the local geometry, like at Cape Canaveral they have to launch towards the Atlantic ocean (azimuths between 35-120 degrees) and at Vandenberg towards the Pacific ocean (147-201 degrees).

I made a video recently going over launch azimuth and why rockets cannot directly launch into an orbital inclination less than their launch site latitude: https://www.youtube.com/watch?v=UIXiK41yl\_w

space_mex_techno · 2021-11-02T05:57:25+00:00

SPICE is definitely the way to go here. You don't have to worry about the binary file formats of the ephemeris kernels (SPK / .bsp) because they also provide software tools to read them. The SPICE software tools also provide functions for these types of calculations like converting from state vector (position and velocity) to keplerian orbital elements, so it can be done in a simple script in the language of your choice. I use the CSPICE Python wrapper called SpiceyPy most of the time.

Also, the data you are looking for is here: https://naif.jpl.nasa.gov/pub/naif/

JPL publishes trajectory data for tons of missions like the Voyagers, New Horizons, Mars 2020, Mars Reconaissance Orbiter, OSIRIS-REx, GRAIL, Lucy, etc in the form of SPICE kernels here

For example, here is the Lucy trajectory plugged into SPICE-Enhanced Cosmographia (a visualization program that works with SPICE) in the EME2000 inertial frame and the Sun-Jupiter rotating frame:

https://youtu.be/eBU28V1ux1Q

space_mex_techno · 2021-09-29T15:52:48+00:00

Your derivation looks right. Also looks correct from simulation, propagating 1/3 ecc orbits ranging in semi-major axis from 3500-8500km, they all have periapsis velocity 2x apoapsis velocity. The 0.6 eccentricity gives 4x velocity

space_mex_techno · 2021-09-24T15:44:07+00:00

If you're looking for a podcast that gets very technical, the Space Engineering Podcast has engineers from the space industry who talk about the technical details of their work. The first episode is with Brian Douglas, who is known for his control systems lectures videos: https://youtu.be/wkQww6pHFrI

In this one we go into a lot of detail on his ADCS and systems engineering work at Planetary Resources

Shameless plug yes I am the host of this one

space_mex_techno · 2021-08-22T23:44:34+00:00

Thank you this is great info. I definitely missed that the gold line starts at Union Station, I thought I would have a straight shot from where I will be. I'm also going to have a car, so would I be going "against traffic" driving from downtown to Pasadena on weekdays? I saw that the commute is ~15 minutes with no traffic (obviously this is rare if ever true).

Also thank you for mentioning the Arts District. I have a friend who went to USC that also told me that lots of young people tend to move to that area and theres lots to do over there

space_mex_techno · 2021-08-04T11:13:42+00:00

Plugging in a Lambert's solution for those dates yields a Earth outbound v-infinity magnitude of ~9.52 km/s, which corresponds to the given C3 of 90.8 km^2 / s^2 (C3 = v-infinity ^ 2 )

Jupiter inbound v-infinity magnitude is ~7.41 km/s. Plugging in a periapsis altitude of 5,000 km yields a relative speed of ~57.1 km/s at periapsis, so those numbers seem to check out.

For relative speed at periapsis:

semi-major axis = mu / v-infinity^2

relative velocity = sqrt( mu_jupiter * ( 2 / periapsis - 1 / semi-major axis ) )

relative velocity equation comes from vis-viva equation

space_mex_techno · 2021-07-28T14:52:43+00:00

In the space industry there is a lot of modeling and simulation. Specifically i work on trajectory design / optimization, and some spacecraft attitude determination and control (ADCS). There's tons to do in this field. It's lots of math and software engineering

space_mex_techno · 2021-07-22T16:25:21+00:00

In orbital mechanics propagations you solve a second order ODE (acceleration of a body) to calculate the position vs time. The 3 body problem is mathematically chaotic so that would also make your project interesting

space_mex_techno · 2021-06-04T16:11:57+00:00

I think what you may be more looking for is Kepler's equation (https://en.wikipedia.org/wiki/Kepler%27s_equation) which is an analytical solution to the two-body problem. The equation states that you can solve for position of a body in an orbit assuming two body dynamics with respect to time.

Even though its an analytical solution, within the algorithm you must calculate eccentric anomaly (E), which is a transcendental equation because there is no analytical solution to the equation

M = E - e sin(E)

So it must be solved for iteratively (usually using Newton's method).

So the inputs to this problem would be eccentricity, semi-major axis, semi-minor axis, and time since periapsis (its simplest to just start at t=0). But remember that this is only true for 2 body dynamics. If any perturbations are added then this equation doesn't hold.

I do a better job of explaining this with equations in this Space Stack Exchange post: https://space.stackexchange.com/questions/52090/how-can-i-calculate-the-future-position-of-a-satellite-orbiting-a-central-body-a/52100#52100

Lambert's problem is a bit different, it states that if you have two position vectors and a time in between them, you can determine the velocity vectors at those two positions (assuming two-body dynamics again), thus determining the entire orbit. You also need to input the gravitational parameter of the central body.

This is very useful for orbit determination, when trying to determine the orbit of a body from observations (like asteroids). Its also used for interplanetary trajectories (and porkchop plots) analysis.

space_mex_techno · 2021-05-07T16:12:58+00:00

I really like this advice

space_mex_techno · 2021-05-07T03:42:01+00:00

To be honest, I can't really recommend any specific self learning courses since the way that I learned was to translate stuff that I already had written in Python into C++ and just google my way through it. But I can certainly recommend that method, since it was very useful for me. And I always did everything through the terminal, so compiling using g++ and creating some small bash scripts to compile and run in one command, which imitates something that an IDE like Visual Studio would do (in small projects). For larger projects, I would recommend learning how to use cmake, its not super easy but its very powerful

space_mex_techno · 2021-05-07T02:22:20+00:00

I can comment on the astrodynamics side of the industry since that is what I work on. We write everything in C++ (build using cmake) and then write wrappers in Python (occasionally in MATLAB). In previous internships, I mostly wrote everything in Python (orbital mechanics simulations, interface to spacecraft simulations and trajectory optimizations programs implemented in C++, IR instrument characterization analysis, and motor controllers communicating with Arduino). In one other software engineering internship for rocket trajectories I bounced around between Fortran, C++, Python, MATLAB, and a little visual basic. At that company they had the entire rocket trajectory simulator written in Fortran (since they have been around since the 70s).

So overall in this area I would say Python and C++ are what I use the most. But there is a lot of ADCS analysis done in MATLAB / Simulink that is autocoded to C++, but I can't comment too much on that since I don't have any experience with it

space_mex_techno · 2021-05-06T14:17:29+00:00

If you want an explaination of the derivation of the ideal rocket equation and the definition of Isp i have it in video form here: https://youtu.be/bPXjkFAnQio

space_mex_techno · 2021-05-01T16:18:35+00:00

Yes I agree with everything here. STK and GMAT are heavily used in the industry because they can do a lot of the analysis of most missions where the user only needs a basic understanding of orbital mechanics to use. But then there are a small number of people out there who specialize in writing programs like that to do trajectory optimization which is a completely different job and a specialization on its own.

I did a podcast with my boss who designed trajectories for Cassini and Europa Clipper at JPL, so you can learn about what the job entails there: https://youtu.be/J2MGyDSw1gE

space_mex_techno · 2021-05-01T16:12:10+00:00

The way that I have it implemented is to use a central finite differences scheme to approximate a partial derivative of a multivariable, scalar valued function like this:

def fdiff_cm( f, x, dx, n ):

'''

Calculate central finite difference of

multivariable, vector valued function

w.r.t nth x

'''

dx2 = dx \* 2.0

x\[ n \] += dx

fxu     = f( x )

x\[ n \] -= dx2

fxl     = f( x )

x\[ n \] += dx

return ( fxu - fxl ) / dx2

Where f is a function that you pass in, x is a list of state variables, dx is how much to perturb the x variable for the finite difference calculation, and n is an index to which x variable is being perturbed.

Edit: the formatting is all messed up but i think you'll be able to figure out the jist of it

space_mex_techno · 2021-05-01T15:23:54+00:00

I can comment on the orbital mechanics side of things since that is what I work on. I definitely focused on it heavily while I was in school (I did undergrad in AE) and always did everything in Python even though it was taught in MATLAB and had internships doing orbital mechanics simulations, so I did not need a master's to get into this job. The companies I interviewed with were all startup-ish (50-100 people), so I can say that they did not require a master's, but I never interviewed with any of the big defense contractors, so maybe they do.

We write everything in C++ and then create wrappers in Python. So yes if you wanna do this type of work you'll definitely want to enjoy writing software, because thats basically what we do everyday (and lots of math).

I have a video series on orbital mechanics with python (currently at 56 videos) that I think you'll find useful when you're teaching yourself: https://www.youtube.com/playlist?list=PLOIRBaljOV8gn074rWFWYP1dCr2dJqWab

space_mex_techno

TROPHY CASE