Message Boards

GROUPS:

Astronomy Aerospace Engineering Physics Wolfram Language Wolfram High School Summer Camp

Anna Krzyzanska

[WSC20] Simulating Satellite Collisions

Anna Krzyzanska

Posted 3 months ago

464 Views

0 Replies

2 Total Likes

Follow this post

Wolfram Notebook

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

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

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},SaveDefinitionsTrue]

In[]:=

Out[]=

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

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},SaveDefinitionsTrue]

In[]:=

Out[]=

Basic Visual of a 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}}},AxesTrue,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}}},AxesTrue,AxesLabel{"x","y","z"}]],{t,0,4Pi},SaveDefinitionsTrue]

Out[]=

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

Manipulate[Graphics3D[{Red,Thick,Line[{Table[{4Sin[n],0,4Cos[n]},{n,0,t+.01,.01}]}]}],{t,0,2Pi},SaveDefinitionsTrue]

In[]:=

Out[]=

The Physics Behind a Collision

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

news[m1_,m2_,v1x_,v1y_,v1z_,v2x_,v2y_,v2z_]:=Flatten[FindInstance[{m1*v1x,m1*v1y,m1*v1z}+{m2*v2x,m2*v2y,m2*v2z}{m3*v3x,m3*v3y,m3*v3z}+{m4*v4x,m4*v4y,m4*v4z}+{m5*v5x,m5*v5y,m5*v5z}+{m6*v6x,m6*v6y,m6*v6z}&&m1+m2m3+m4+m5+m6&&m3>0&&m4>0&&m5>0&&m6>0&&v3x==v4x==v5x==v6x0&&v3y≠v3z≠v4y≠v4z≠v5y≠v5z≠v6y≠v6z≠0&&v5y/v5z≠v4y/v4z≠v3y/v3z,{m3,v3x,v3y,v3z,m4,v4x,v4y,v4z,m5,v5x,v5y,v5z,m6,v6x,v6y,v6z},Reals]]

In[]:=

news[1,1,0,14,-1,0,-15,1]

In[]:=

m3

,v3x0,v3y-64,v3z-8,m4

,v4x0,v4y-16,v4z-4,m5

,v5x0,v5y-2,v5z-1,m61,v6x0,v6y20,v6z



Out[]=

We can rearrange the equation

u.v=|u||v|cos[angle]

to find the angle of each satellite relative to the velocity of Satellite 1.

Finding the angle between satellites

ArcCos[{0,0,-1}.{1,1,1}/(Sqrt[1^2+1^2+1^2]*Sqrt[0^2+0^2+(-1)^2])]

In[]:=

ArcCos-



Out[]=

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.

collisionsGridNoX[m1_,m2_,v1x_,v1y_,v1z_,v2x_,v2y_,v2z_]:=Block[{v1={v1x,v1y,v1z},v2={v2x,v2y,v2z},v3={v3x,v3y,v3z},v4={v4x,v4y,v4z},v5={v5x,v5y,v5z},v6={v6x,v6y,v6z}},Grid[{{" ","Satellite1","Satellite2","Satellite 3","Satellite 4","Satellite 5","Satellite 6"},{"Mass",m1,m2,m3,m4,m5,m6},{"Velocity",v1,v2,v3,v4,v5,v6},{"Speed",Norm[v1],Norm[v2],Norm[v3],Norm[v4],Norm[v5],Norm[v6]},{"Angle",N[ArcCos[v1.v1/(Norm[v1]*Norm[v1])]],ArcCos[v1.v2/(Norm[v2]*Norm[v1])],N[ArcCos[v1.v3/(Norm[v3]*Norm[v1])]],N[ArcCos[v1.v4/(Norm[v4]*Norm[v1])]],N[ArcCos[v1.v5/(Norm[v5]*Norm[v1])]],N[ArcCos[v1.v6/(Norm[v6]*Norm[v1])]]}}/.news[m1,m2,v1x,v1y,v1z,v2x,v2y,v2z],FrameAll]]

In[]:=

collisionsGridNoX[2,2,0,0,-75,0,-75,0]

In[]:=

	Satellite1	Satellite2	Satellite 3	Satellite 4	Satellite 5	Satellite 6
Mass	2	2	1	1	1	1
Velocity	{0,0,-75}	{0,-75,0}	{0,-64,-8}	{0,-16,-4}	{0,-2,-1}	{0,-68,-137}
Speed	75	75	8 65	4 17	5	23393
Angle	0.	π 2	1.44644	1.32582	1.10715	0.460724

Out[]=

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

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

RotationTransform[Pi/3,{1,0,0}]@{16Sin[t],0,16Cos[t]}

In[]:=

16Sin[t],-8

Cos[t],8Cos[t]

Out[]=

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!

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

Takingtheratiosofthespeedsfromthegrid

75,75,8

23393



N[Ratios[75,75,8

23393

]]

In[]:=

{1.,0.859974,0.255704,0.135582,68.4003}

Out[]=

However, multiplying by a coefficient in our Trig function will also change the position each newly formed satellite starts at.Thus, for each of the satellites we must find how much the position is shifted and add the necessary amount to account for it. For us this means adding the amount required to make the angle in the trig function equal to Pi/2, since that is a t value where our satellites collide at {16,0,0}.

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

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.

partSimulaLined[2,2,0,0,-75,0,-75,0]

In[]:=

Out[]=

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

Orbit

◼

Satellite

◼

Collision

◼

Simulation

◼

POSTED BY: Anna Krzyzanska

Answer

Reply to this discussion

Reply Preview

Attachments

Remove Add a file to this post

Follow this discussion

or Discard

Group Abstract

Feedback