WolframAlpha.com
WolframCloud.com
All Sites & Public Resources...
Products & Services
Wolfram|One
Mathematica
Wolfram|Alpha Notebook Edition
Programming Lab
Finance Platform
SystemModeler
Wolfram Player
Wolfram Engine
WolframScript
Enterprise Private Cloud
Enterprise Mathematica
Wolfram|Alpha Appliance
Enterprise Solutions
Corporate Consulting
Technical Consulting
Wolfram|Alpha Business Solutions
Resource System
Data Repository
Neural Net Repository
Function Repository
Wolfram|Alpha
Wolfram|Alpha Pro
Problem Generator
API
Data Drop
Products for Education
Mobile Apps
Wolfram Player
Wolfram Cloud App
Wolfram|Alpha for Mobile
Wolfram|Alpha-Powered Apps
Services
Paid Project Support
Wolfram U
Summer Programs
All Products & Services »
Technologies
Wolfram Language
Revolutionary knowledge-based programming language.
Wolfram Cloud
Central infrastructure for Wolfram's cloud products & services.
Wolfram Science
Technology-enabling science of the computational universe.
Wolfram Notebooks
The preeminent environment for any technical workflows.
Wolfram Engine
Software engine implementing the Wolfram Language.
Wolfram Natural Language Understanding System
Knowledge-based broadly deployed natural language.
Wolfram Data Framework
Semantic framework for real-world data.
Wolfram Universal Deployment System
Instant deployment across cloud, desktop, mobile, and more.
Wolfram Knowledgebase
Curated computable knowledge powering Wolfram|Alpha.
All Technologies »
Solutions
Engineering, R&D
Aerospace & Defense
Chemical Engineering
Control Systems
Electrical Engineering
Image Processing
Industrial Engineering
Mechanical Engineering
Operations Research
More...
Finance, Statistics & Business Analysis
Actuarial Sciences
Bioinformatics
Data Science
Econometrics
Financial Risk Management
Statistics
More...
Education
All Solutions for Education
Trends
Machine Learning
Multiparadigm Data Science
Internet of Things
High-Performance Computing
Hackathons
Software & Web
Software Development
Authoring & Publishing
Interface Development
Web Development
Sciences
Astronomy
Biology
Chemistry
More...
All Solutions »
Learning & Support
Learning
Wolfram Language Documentation
Fast Introduction for Programmers
Wolfram U
Videos & Screencasts
Wolfram Language Introductory Book
Webinars & Training
Summer Programs
Books
Need Help?
Support FAQ
Wolfram Community
Contact Support
Premium Support
Paid Project Support
Technical Consulting
All Learning & Support »
Company
About
Company Background
Wolfram Blog
Events
Contact Us
Work with Us
Careers at Wolfram
Internships
Other Wolfram Language Jobs
Initiatives
Wolfram Foundation
MathWorld
Computer-Based Math
A New Kind of Science
Wolfram Technology for Hackathons
Student Ambassador Program
Wolfram for Startups
Demonstrations Project
Wolfram Innovator Awards
Wolfram + Raspberry Pi
Summer Programs
More...
All Company »
Search
WOLFRAM COMMUNITY
Connect with users of Wolfram technologies to learn, solve problems and share ideas
Join
Sign In
Dashboard
Groups
People
Message Boards
Answer
(
Unmark
)
Mark as an Answer
GROUPS:
Astronomy
Aerospace Engineering
Physics
Wolfram Language
Wolfram High School Summer Camp
2
Anna Krzyzanska
[WSC20] Simulating Satellite Collisions
Anna Krzyzanska
Posted
10 months ago
1149 Views
|
0 Replies
|
2 Total Likes
Follow this post
|
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
M
a
n
i
p
u
l
a
t
e
[
G
r
a
p
h
i
c
s
3
D
[
{
W
h
i
t
e
,
O
p
a
c
i
t
y
[
.
0
0
1
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
6
]
,
G
r
a
y
,
O
p
a
c
i
t
y
[
.
2
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
4
]
,
B
l
u
e
,
O
p
a
c
i
t
y
[
.
9
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
3
]
,
B
l
a
c
k
,
S
p
h
e
r
e
[
{
4
S
i
n
[
t
]
,
4
C
o
s
[
t
]
,
0
}
,
.
5
]
,
P
l
o
t
R
a
n
g
e
{
{
-
5
,
5
}
,
{
-
5
,
5
}
,
{
-
2
,
2
}
}
}
]
,
{
t
,
0
,
2
P
i
}
,
S
a
v
e
D
e
f
i
n
i
t
i
o
n
s
T
r
u
e
]
I
n
[
]
:
=
t
O
u
t
[
]
=
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
M
a
n
i
p
u
l
a
t
e
[
G
r
a
p
h
i
c
s
3
D
[
{
W
h
i
t
e
,
O
p
a
c
i
t
y
[
.
0
0
1
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
6
]
,
G
r
a
y
,
O
p
a
c
i
t
y
[
.
2
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
4
]
,
B
l
u
e
,
O
p
a
c
i
t
y
[
.
9
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
3
]
,
G
r
e
e
n
,
S
p
h
e
r
e
[
{
4
S
i
n
[
t
]
,
4
C
o
s
[
t
]
,
0
}
,
.
5
]
,
P
i
n
k
,
S
p
h
e
r
e
[
{
4
S
i
n
[
t
]
,
0
,
4
C
o
s
[
t
]
}
,
.
5
]
,
P
l
o
t
R
a
n
g
e
{
{
-
5
,
5
}
,
{
-
5
,
5
}
,
{
-
2
,
2
}
}
}
]
,
{
t
,
0
,
2
P
i
}
,
S
a
v
e
D
e
f
i
n
i
t
i
o
n
s
T
r
u
e
]
I
n
[
]
:
=
t
O
u
t
[
]
=
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
M
a
n
i
p
u
l
a
t
e
[
I
f
[
4
C
o
s
[
t
]
≥
0
&
&
t
<
P
i
/
2
,
G
r
a
p
h
i
c
s
3
D
[
{
R
e
d
,
T
h
i
c
k
,
L
i
n
e
[
{
T
a
b
l
e
[
{
4
S
i
n
[
n
]
,
0
,
4
C
o
s
[
n
]
}
,
{
n
,
0
,
t
+
.
0
1
,
.
0
1
}
]
}
]
,
W
h
i
t
e
,
O
p
a
c
i
t
y
[
.
0
0
1
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
6
]
,
G
r
a
y
,
O
p
a
c
i
t
y
[
.
2
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
4
]
,
B
l
u
e
,
O
p
a
c
i
t
y
[
.
5
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
3
]
,
G
r
e
e
n
,
S
p
h
e
r
e
[
{
4
S
i
n
[
t
]
,
4
C
o
s
[
t
]
,
0
}
,
.
5
]
,
P
i
n
k
,
S
p
h
e
r
e
[
{
4
S
i
n
[
t
]
,
0
,
4
C
o
s
[
t
]
}
,
.
5
]
,
P
l
o
t
R
a
n
g
e
{
{
-
5
,
5
}
,
{
-
5
,
5
}
,
{
-
2
,
2
}
}
}
,
A
x
e
s
T
r
u
e
,
A
x
e
s
L
a
b
e
l
{
"
x
"
,
"
y
"
,
"
z
"
}
]
,
G
r
a
p
h
i
c
s
3
D
[
{
R
e
d
,
T
h
i
c
k
,
L
i
n
e
[
{
T
a
b
l
e
[
{
4
S
i
n
[
n
]
,
0
,
4
C
o
s
[
n
]
}
,
{
n
,
0
,
t
+
.
0
1
,
.
0
1
}
]
}
]
,
W
h
i
t
e
,
O
p
a
c
i
t
y
[
.
0
0
1
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
6
]
,
G
r
a
y
,
O
p
a
c
i
t
y
[
.
2
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
4
]
,
B
l
u
e
,
O
p
a
c
i
t
y
[
.
5
]
,
S
p
h
e
r
e
[
{
0
,
0
,
0
}
,
3
]
,
G
r
e
e
n
,
S
p
h
e
r
e
[
{
4
S
i
n
[
t
]
,
4
C
o
s
[
t
]
,
0
}
,
.
2
5
]
,
P
i
n
k
,
S
p
h
e
r
e
[
{
4
S
i
n
[
t
]
,
0
,
4
C
o
s
[
t
]
}
,
.
2
5
]
,
Y
e
l
l
o
w
,
S
p
h
e
r
e
[
{
4
S
i
n
[
t
]
,
-
4
C
o
s
[
t
]
,
0
}
,
.
2
5
]
,
O
r
a
n
g
e
,
S
p
h
e
r
e
[
{
4
S
i
n
[
t
]
,
0
,
-
4
C
o
s
[
t
]
}
,
.
2
5
]
,
P
l
o
t
R
a
n
g
e
{
{
-
5
,
5
}
,
{
-
5
,
5
}
,
{
-
2
,
2
}
}
}
,
A
x
e
s
T
r
u
e
,
A
x
e
s
L
a
b
e
l
{
"
x
"
,
"
y
"
,
"
z
"
}
]
]
,
{
t
,
0
,
4
P
i
}
,
S
a
v
e
D
e
f
i
n
i
t
i
o
n
s
T
r
u
e
]
t
O
u
t
[
]
=
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
M
a
n
i
p
u
l
a
t
e
[
G
r
a
p
h
i
c
s
3
D
[
{
R
e
d
,
T
h
i
c
k
,
L
i
n
e
[
{
T
a
b
l
e
[
{
4
S
i
n
[
n
]
,
0
,
4
C
o
s
[
n
]
}
,
{
n
,
0
,
t
+
.
0
1
,
.
0
1
}
]
}
]
}
]
,
{
t
,
0
,
2
P
i
}
,
S
a
v
e
D
e
f
i
n
i
t
i
o
n
s
T
r
u
e
]
I
n
[
]
:
=
t
O
u
t
[
]
=
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
n
e
w
s
[
m
1
_
,
m
2
_
,
v
1
x
_
,
v
1
y
_
,
v
1
z
_
,
v
2
x
_
,
v
2
y
_
,
v
2
z
_
]
:
=
F
l
a
t
t
e
n
[
F
i
n
d
I
n
s
t
a
n
c
e
[
{
m
1
*
v
1
x
,
m
1
*
v
1
y
,
m
1
*
v
1
z
}
+
{
m
2
*
v
2
x
,
m
2
*
v
2
y
,
m
2
*
v
2
z
}
{
m
3
*
v
3
x
,
m
3
*
v
3
y
,
m
3
*
v
3
z
}
+
{
m
4
*
v
4
x
,
m
4
*
v
4
y
,
m
4
*
v
4
z
}
+
{
m
5
*
v
5
x
,
m
5
*
v
5
y
,
m
5
*
v
5
z
}
+
{
m
6
*
v
6
x
,
m
6
*
v
6
y
,
m
6
*
v
6
z
}
&
&
m
1
+
m
2
m
3
+
m
4
+
m
5
+
m
6
&
&
m
3
>
0
&
&
m
4
>
0
&
&
m
5
>
0
&
&
m
6
>
0
&
&
v
3
x
=
=
v
4
x
=
=
v
5
x
=
=
v
6
x
0
&
&
v
3
y
≠
v
3
z
≠
v
4
y
≠
v
4
z
≠
v
5
y
≠
v
5
z
≠
v
6
y
≠
v
6
z
≠
0
&
&
v
5
y
/
v
5
z
≠
v
4
y
/
v
4
z
≠
v
3
y
/
v
3
z
,
{
m
3
,
v
3
x
,
v
3
y
,
v
3
z
,
m
4
,
v
4
x
,
v
4
y
,
v
4
z
,
m
5
,
v
5
x
,
v
5
y
,
v
5
z
,
m
6
,
v
6
x
,
v
6
y
,
v
6
z
}
,
R
e
a
l
s
]
]
I
n
[
]
:
=
n
e
w
s
[
1
,
1
,
0
,
1
4
,
-
1
,
0
,
-
1
5
,
1
]
I
n
[
]
:
=
m
3
1
4
,
v
3
x
0
,
v
3
y
-
6
4
,
v
3
z
-
8
,
m
4
1
4
,
v
4
x
0
,
v
4
y
-
1
6
,
v
4
z
-
4
,
m
5
1
2
,
v
5
x
0
,
v
5
y
-
2
,
v
5
z
-
1
,
m
6
1
,
v
6
x
0
,
v
6
y
2
0
,
v
6
z
7
2
O
u
t
[
]
=
We can rearrange the equation
u
.
v
=
|
u
|
|
v
|
c
o
s
[
a
n
g
l
e
]
to find the angle of each satellite relative to the velocity of Satellite 1.
Finding the angle between satellites
A
r
c
C
o
s
[
{
0
,
0
,
-
1
}
.
{
1
,
1
,
1
}
/
(
S
q
r
t
[
1
^
2
+
1
^
2
+
1
^
2
]
*
S
q
r
t
[
0
^
2
+
0
^
2
+
(
-
1
)
^
2
]
)
]
I
n
[
]
:
=
A
r
c
C
o
s
-
1
3
O
u
t
[
]
=
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.
c
o
l
l
i
s
i
o
n
s
G
r
i
d
N
o
X
[
m
1
_
,
m
2
_
,
v
1
x
_
,
v
1
y
_
,
v
1
z
_
,
v
2
x
_
,
v
2
y
_
,
v
2
z
_
]
:
=
B
l
o
c
k
[
{
v
1
=
{
v
1
x
,
v
1
y
,
v
1
z
}
,
v
2
=
{
v
2
x
,
v
2
y
,
v
2
z
}
,
v
3
=
{
v
3
x
,
v
3
y
,
v
3
z
}
,
v
4
=
{
v
4
x
,
v
4
y
,
v
4
z
}
,
v
5
=
{
v
5
x
,
v
5
y
,
v
5
z
}
,
v
6
=
{
v
6
x
,
v
6
y
,
v
6
z
}
}
,
G
r
i
d
[
{
{
"
"
,
"
S
a
t
e
l
l
i
t
e
1
"
,
"
S
a
t
e
l
l
i
t
e
2
"
,
"
S
a
t
e
l
l
i
t
e
3
"
,
"
S
a
t
e
l
l
i
t
e
4
"
,
"
S
a
t
e
l
l
i
t
e
5
"
,
"
S
a
t
e
l
l
i
t
e
6
"
}
,
{
"
M
a
s
s
"
,
m
1
,
m
2
,
m
3
,
m
4
,
m
5
,
m
6
}
,
{
"
V
e
l
o
c
i
t
y
"
,
v
1
,
v
2
,
v
3
,
v
4
,
v
5
,
v
6
}
,
{
"
S
p
e
e
d
"
,
N
o
r
m
[
v
1
]
,
N
o
r
m
[
v
2
]
,
N
o
r
m
[
v
3
]
,
N
o
r
m
[
v
4
]
,
N
o
r
m
[
v
5
]
,
N
o
r
m
[
v
6
]
}
,
{
"
A
n
g
l
e
"
,
N
[
A
r
c
C
o
s
[
v
1
.
v
1
/
(
N
o
r
m
[
v
1
]
*
N
o
r
m
[
v
1
]
)
]
]
,
A
r
c
C
o
s
[
v
1
.
v
2
/
(
N
o
r
m
[
v
2
]
*
N
o
r
m
[
v
1
]
)
]
,
N
[
A
r
c
C
o
s
[
v
1
.
v
3
/
(
N
o
r
m
[
v
3
]
*
N
o
r
m
[
v
1
]
)
]
]
,
N
[
A
r
c
C
o
s
[
v
1
.
v
4
/
(
N
o
r
m
[
v
4
]
*
N
o
r
m
[
v
1
]
)
]
]
,
N
[
A
r
c
C
o
s
[
v
1
.
v
5
/
(
N
o
r
m
[
v
5
]
*
N
o
r
m
[
v
1
]
)
]
]
,
N
[
A
r
c
C
o
s
[
v
1
.
v
6
/
(
N
o
r
m
[
v
6
]
*
N
o
r
m
[
v
1
]
)
]
]
}
}
/
.
n
e
w
s
[
m
1
,
m
2
,
v
1
x
,
v
1
y
,
v
1
z
,
v
2
x
,
v
2
y
,
v
2
z
]
,
F
r
a
m
e
A
l
l
]
]
I
n
[
]
:
=
c
o
l
l
i
s
i
o
n
s
G
r
i
d
N
o
X
[
2
,
2
,
0
,
0
,
-
7
5
,
0
,
-
7
5
,
0
]
I
n
[
]
:
=
S
a
t
e
l
l
i
t
e
1
S
a
t
e
l
l
i
t
e
2
S
a
t
e
l
l
i
t
e
3
S
a
t
e
l
l
i
t
e
4
S
a
t
e
l
l
i
t
e
5
S
a
t
e
l
l
i
t
e
6
M
a
s
s
2
2
1
1
1
1
V
e
l
o
c
i
t
y
{
0
,
0
,
-
7
5
}
{
0
,
-
7
5
,
0
}
{
0
,
-
6
4
,
-
8
}
{
0
,
-
1
6
,
-
4
}
{
0
,
-
2
,
-
1
}
{
0
,
-
6
8
,
-
1
3
7
}
S
p
e
e
d
7
5
7
5
8
6
5
4
1
7
5
2
3
3
9
3
A
n
g
l
e
0
.
π
2
1
.
4
4
6
4
4
1
.
3
2
5
8
2
1
.
1
0
7
1
5
0
.
4
6
0
7
2
4
O
u
t
[
]
=
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
R
o
t
a
t
i
o
n
T
r
a
n
s
f
o
r
m
[
P
i
/
3
,
{
1
,
0
,
0
}
]
@
{
1
6
S
i
n
[
t
]
,
0
,
1
6
C
o
s
[
t
]
}
I
n
[
]
:
=
1
6
S
i
n
[
t
]
,
-
8
3
C
o
s
[
t
]
,
8
C
o
s
[
t
]
O
u
t
[
]
=
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."
T
a
k
i
n
g
t
h
e
r
a
t
i
o
s
o
f
t
h
e
s
p
e
e
d
s
f
r
o
m
t
h
e
g
r
i
d
7
5
,
7
5
,
8
6
5
,
4
1
7
,
5
,
2
3
3
9
3
N
[
R
a
t
i
o
s
[
7
5
,
7
5
,
8
6
5
,
4
1
7
,
5
,
2
3
3
9
3
]
]
I
n
[
]
:
=
{
1
.
,
0
.
8
5
9
9
7
4
,
0
.
2
5
5
7
0
4
,
0
.
1
3
5
5
8
2
,
6
8
.
4
0
0
3
}
O
u
t
[
]
=
H
o
w
e
v
e
r
,
m
u
l
t
i
p
l
y
i
n
g
b
y
a
c
o
e
f
f
i
c
i
e
n
t
i
n
o
u
r
T
r
i
g
f
u
n
c
t
i
o
n
w
i
l
l
a
l
s
o
c
h
a
n
g
e
t
h
e
p
o
s
i
t
i
o
n
e
a
c
h
n
e
w
l
y
f
o
r
m
e
d
s
a
t
e
l
l
i
t
e
s
t
a
r
t
s
a
t
.
T
h
u
s
,
f
o
r
e
a
c
h
o
f
t
h
e
s
a
t
e
l
l
i
t
e
s
w
e
m
u
s
t
f
i
n
d
h
o
w
m
u
c
h
t
h
e
p
o
s
i
t
i
o
n
i
s
s
h
i
f
t
e
d
a
n
d
a
d
d
t
h
e
n
e
c
e
s
s
a
r
y
a
m
o
u
n
t
t
o
a
c
c
o
u
n
t
f
o
r
i
t
.
F
o
r
u
s
t
h
i
s
m
e
a
n
s
a
d
d
i
n
g
t
h
e
a
m
o
u
n
t
r
e
q
u
i
r
e
d
t
o
m
a
k
e
t
h
e
a
n
g
l
e
i
n
t
h
e
t
r
i
g
f
u
n
c
t
i
o
n
e
q
u
a
l
t
o
P
i
/
2
,
s
i
n
c
e
t
h
a
t
i
s
a
t
v
a
l
u
e
w
h
e
r
e
o
u
r
s
a
t
e
l
l
i
t
e
s
c
o
l
l
i
d
e
a
t
{
1
6
,
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.
p
a
r
t
S
i
m
u
l
a
L
i
n
e
d
[
2
,
2
,
0
,
0
,
-
7
5
,
0
,
-
7
5
,
0
]
I
n
[
]
:
=
t
O
u
t
[
]
=
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
Mark as an Answer
Reply
|
Flag
Reply to this discussion
in reply to
Add Notebook
Community posts can be styled and formatted using the
Markdown syntax
.
Tag limit exceeded
Note: Only the first five people you tag will receive an email notification; the other tagged names will appear as links to their profiles.
Publish anyway
Cancel
Reply Preview
Attachments
Remove
Add a file to this post
Follow this discussion
or
Discard
Group Abstract
Be respectful. Review our
Community Guidelines
to understand your role and responsibilities.
Community Terms of Use
Feedback
Enable JavaScript to interact with content and submit forms on Wolfram websites.
Learn how »