Introduction
Introduction
While there have been no major collisions between satellites orbiting Earth, as more and more are launched into orbit, it is clear that satellite collisions may one day be an issue. In this project we attempt to simulate collisions between satellites by incorporating the basic physics behind a satellite collision into a 3D visual interactive model. Please note, I have ignored gravity and general relativity for my own sanity.
The Basics of Visually Simulating Objects in Orbit
The Basics of Visually Simulating Objects in Orbit
Simulating an Object in Orbit
Simulating an Object in Orbit
The first step in the visual simulation of a satellite in orbit is of course a basic visualization of a smaller sphere, representing the satellite, orbiting a larger sphere, representing the Earth. This seems very fundamental, but is still needed to achieve the final result. While the varying radii of all the spheres serve mainly to enhance the visualization, they are all arbitrary values and any values in the same ratio would produce essentially the same result. For sake of simplicity, the Earth will be visualized as a stationary sphere and the orbit of the satellite will be circular in the final simulation as well.
Basic orbit visual
In[]:=
Manipulate[Graphics3D[{White,Opacity[.001],Sphere[{0,0,0},6],Gray,Opacity[.2],Sphere[{0,0,0},4],Blue,Opacity[.9],Sphere[{0,0,0},3],Black,Sphere[{4Sin[t],4Cos[t],0},.5],PlotRange{{-5,5},{-5,5},{-2,2}}}],{t,0,2Pi},SaveDefinitionsTrue]
Out[]=
Simulating Two Objects in Orbit
Simulating Two Objects in Orbit
As you might imagine, simulating two spheres in orbit is quite similar to simulating one sphere in orbit. One of the simplest ways to visually simulate two spheres on different orbital paths is to make their orbits perpendicular. This can simply be done by moving the 4Cos[t] value from the y coordinate of our previous sphere to the z coordinate when plotting our second sphere.
Same as code for one sphere but with second sphere in perpendicular orbit and different colors
In[]:=
Manipulate[Graphics3D[{White,Opacity[.001],Sphere[{0,0,0},6],Gray,Opacity[.2],Sphere[{0,0,0},4],Blue,Opacity[.9],Sphere[{0,0,0},3],Green,Sphere[{4Sin[t],4Cos[t],0},.5],Pink,Sphere[{4Sin[t],0,4Cos[t]},.5],PlotRange{{-5,5},{-5,5},{-2,2}}}],{t,0,2Pi},SaveDefinitionsTrue]
Out[]=
Basic Visual of a Collision
Basic Visual of a Collision
Basic Collision
Basic Collision
In the basic simulation of the two spheres, their orbits intersect and the two spheres overlap. In our simulation, this overlapping will be considered a collision. From this point on, we will refer to spheres as satellites. If two satellites were to collide, pieces of them would likely break off. In our simulation, a collision of two satellites will arbitrarily result in four smaller pieces which become our new satellites and continue in their own orbits. Using the If function, since we chose to create the simulation in such a way that the satellites first collide at Pi/2, we can simulate four smaller satellites created by the collision. Of course, the result simulated is not realistic at the moment, but for the purpose of having a foundation to build off of, it is simulated regardless its accuracy.
Visual of collision resulting in four smaller satellites
Manipulate[If[4Cos[t]≥0&&t<Pi/2,Graphics3D[{Red,Thick,Line[{Table[{4Sin[n],0,4Cos[n]},{n,0,t+.01,.01}]}],White,Opacity[.001],Sphere[{0,0,0},6],Gray,Opacity[.2],Sphere[{0,0,0},4],Blue,Opacity[.5],Sphere[{0,0,0},3],Green,Sphere[{4Sin[t],4Cos[t],0},.5],Pink,Sphere[{4Sin[t],0,4Cos[t]},.5],PlotRange{{-5,5},{-5,5},{-2,2}}},AxesTrue,AxesLabel{"x","y","z"}],Graphics3D[{Red,Thick,Line[{Table[{4Sin[n],0,4Cos[n]},{n,0,t+.01,.01}]}],White,Opacity[.001],Sphere[{0,0,0},6],Gray,Opacity[.2],Sphere[{0,0,0},4],Blue,Opacity[.5],Sphere[{0,0,0},3],Green,Sphere[{4Sin[t],4Cos[t],0},.25],Pink,Sphere[{4Sin[t],0,4Cos[t]},.25],Yellow,Sphere[{4Sin[t],-4Cos[t],0},.25],Orange,Sphere[{4Sin[t],0,-4Cos[t]},.25],PlotRange{{-5,5},{-5,5},{-2,2}}},AxesTrue,AxesLabel{"x","y","z"}]],{t,0,4Pi},SaveDefinitionsTrue]
Out[]=
Tracing the Path of Orbit
Tracing the Path of Orbit
The simulated collision above evidently has a red line that curves following one of the spheres in orbit. While it appears that the resulting traced orbit is circular, this visual is actually generated using a line and a table. The line has a very similar structure to the sphere it follows. Using the Table function it draws a segment between two points which progressively curve to form a circular shape in steps of size 0.01. While the result is not a perfect circle, it appears to be, and that is sufficient for the purposes of our simulation. The code below shows how this is drawn separate from the rest of the visualization.
Draws approximate circle that is used to trace orbit
In[]:=
Manipulate[Graphics3D[{Red,Thick,Line[{Table[{4Sin[n],0,4Cos[n]},{n,0,t+.01,.01}]}]}],{t,0,2Pi},SaveDefinitionsTrue]
Out[]=
The Physics Behind a Collision
The Physics Behind a Collision
Conserving Momentum
Conserving Momentum
Up until now, the visual simulations shown had basic structures and were far from accurate representations of what a collision between satellites would entail. In attempt to be more accurate, the function below takes in mass and velocity values for both of the initial satellites and outputs the mass and velocities of the 4 four satellites that result after the collision by finding values that satisfy the equation for the conservation of momentum. Since we chose our first collision to be at the point {16,0,0}, in order for the resulting vectors to be on the same plane, they must have an x value that remains unchanged.
Chooses velocities and masses of new satellites so they conserve momentum
Finding the angle between satellites
Now, you have noticed that news outputs a list of rules, which doesn't really help visualize the collision on its own. So, we create a function that can use these values in various equations and output a nifty grid that displays this information nicely.
In our final simulation we will use a similar function that outputs a list instead of a grid so it is easier to extract data from it.
Incorporating Physics into the Simulation
Incorporating Physics into the Simulation
FinANGLEing Angles
FinANGLEing Angles
So you'd think that we have a pretty grid with angle values we could easily incorporate into the function, but it's not that simple. We have to add in a couple of RotationTransforms (take the dot product of a rotation matrix and one of our standard perpendicular vectors) in order to change the orientation of the satellites that result after the collision.
Example of changing the angle of a newly formed satellite's orbit
When we incorporate this in the overall simulation, the angle of each satellite relative to Satellite 1 will be used in the rotation transformation.
Speed!
Speed!
Now while angles were fairly simple to incorporate into our simulation, speed poses another issue. Our speed values as taken from the grid will be multiplied by the "t" in the trig functions defining their respective satellites.Well, at least theoretically. Since some of the speed values are very high, we'll be better off if we take the ratio between the speeds and use those values as our coefficients for "t."
To do this, we take the difference of Pi/2 and the product of the current coefficient of the t value in the trig function of one of the spheres and Pi/2. The resulting value is what we must add to the product of the t value and its coefficient within each trig function for that sphere. This shifts the initial position of the newly formed satellite to the point of collision.
Final Output
Final Output
And it all culminates to this beast! If you look carefully through the functions locally defined in the module, you'll see everything we discussed earlier all wrapped up in this giant function! It outputs our (somewhat) accurate visualization of two satellites colliding and separating into four smaller satellites that go off at various angles based on what our functions generated.
Future Plans
Future Plans
As you may have noticed, there is only one collision in our simulation that actually results in the satellites breaking apart into smaller satellites. Originally, I had planned to simulate satellite collision chain reactions and I plan to do exactly that in the future. This would of course include generalizing my functions more so they work for values where I do not know the point of collision and such. This would be more challenging and computationally intensive, but I am excited to look into it later on.
Keywords
Keywords
◼
Orbit
◼
Satellite
◼
Collision
◼
Simulation