def test_add_particle(self):
system = classes.System()
system.add_particle(classes.Particle())
self.assertEqual(1, len(system.particles))
self.assertEqual(system, system.particles[0].system)
system.add_particle(classes.Particle())
self.assertEqual(2, len(system.particles))
def checkbox_solarSystemExample(self):
if self.checkBox.isChecked():
self.groupBox_4.setEnabled(False)
self.comboBox.setEnabled(False)
global _particle_list
_particle_list = []
#Sun
_particle_list.append(
myClass.Particle(myClass.Position(0, 0, 0),
myClass.Velocity(0, 0, 0), 332900,
[1, 0.8, 0]))
#Mercury
_particle_list.append(
myClass.Particle(myClass.Position(3.87, 0, 0),
myClass.Velocity(0, 47360, 0), 0.055,
[0.7, 0.6, 0.6]))
#Venus
_particle_list.append(
myClass.Particle(myClass.Position(7.233, 0, 0),
myClass.Velocity(0, 35020, 0), 0.815,
[0.9, 0.8, 0.7]))
#Earth
_particle_list.append(
myClass.Particle(myClass.Position(10, 0, 0),
myClass.Velocity(0, 29783, 0), 1,
[0.4, 0.6, 0.8]))
#Mars
_particle_list.append(
myClass.Particle(myClass.Position(15.24, 0, 0),
myClass.Velocity(0, 24100, 0), 0.107,
[1, 0.5, 0]))
#Jupiter
_particle_list.append(
myClass.Particle(myClass.Position(52, 0, 0),
myClass.Velocity(0, 13070, 0), 318,
[1, 0.8, 0.6]))
#Saturn
_particle_list.append(
myClass.Particle(myClass.Position(100, 0, 0),
myClass.Velocity(0, 9690, 0), 95,
[0.8, 0.7, 0.1]))
#Uran
_particle_list.append(
myClass.Particle(myClass.Position(192.3, 0, 0),
myClass.Velocity(0, 6810, 0), 14.6,
[0.6, 0.65, 1]))
#Neptune
_particle_list.append(
myClass.Particle(myClass.Position(301, 0, 0),
myClass.Velocity(0, 5430, 0), 17.1,
[0.1, 0.3, 1]))
#No Pluto :G
self.timer.start(self._dt)
self.zoom = 280
else:
self.comboBox.setEnabled(True)
self.combobox_numberChoice()
def test_make_cell_list(self):
system = classes.System(width=500., height=200., cell_length=2.)
system.add_particle(classes.Particle())
system.add_particle(classes.Particle())
system.add_particle(classes.Particle())
system.add_particle(classes.Particle())
system.particles[0].state[:2] = [1.4, 1.2]
system.particles[1].state[:2] = [4.4, 3.2]
system.particles[2].state[:2] = [8.4, 5.2]
system.particles[3].state[:2] = [9.4, 5.7]
system.populate_cell_list()
self.assertEqual([0], system.cell_list[0][0])
self.assertEqual([1], system.cell_list[1][2])
self.assertEqual([2, 3], system.cell_list[2][4])
def test_get_neighbors(self):
system = classes.System(width=6., height=7., cell_length=1.)
system.add_particle(classes.Particle())
system.add_particle(classes.Particle())
system.add_particle(classes.Particle())
system.add_particle(classes.Particle())
system.add_particle(classes.Particle())
system.particles[0].state[:2] = [2.5, 2.5]
system.particles[1].state[:2] = [1.5, 2.5]
system.particles[2].state[:2] = [0.5, 3.5]
system.particles[3].state[:2] = [5.5, 3.5]
system.particles[4].state[:2] = [3.5, 6.5]
system.populate_cell_list()
self.assertEqual(2, len(system.particles[0].neighbor_ids))
self.assertEqual(3, len(system.particles[1].neighbor_ids))
self.assertEqual([0, 2, 3], sorted(system.particles[1].neighbor_ids))
self.assertEqual(0, len(system.particles[4].neighbor_ids))
def CalculateSolar(mytype, particle_list, timer_step):
G = 6.67408 * (10**-11)
constRadius = 14959787070
constMass = 5.9726 * 10**24
x_n = [p.x * constRadius for p in particle_list]
y_n = [p.y * constRadius for p in particle_list]
z_n = [p.z * constRadius for p in particle_list]
position = [myClass.Position(x, y, z) for x, y, z in zip(x_n, y_n, z_n)]
u_n = [p.u for p in particle_list]
v_n = [p.v for p in particle_list]
w_n = [p.w for p in particle_list]
m_n = [p.m * constMass for p in particle_list]
col_n = [p.color for p in particle_list]
length = len(x_n)
_particle_list = []
if length < 9:
print('stop')
else:
x_n1 = []
y_n1 = []
z_n1 = []
u_n1 = []
v_n1 = []
w_n1 = []
if (mytype == 0):
print('Odeint')
[x_n1, y_n1, z_n1, u_n1, v_n1,
w_n1] = CalculateOdeint(G, x_n, y_n, z_n, u_n, v_n, w_n, m_n,
timer_step)
elif (mytype == 1):
print('Verlet')
[x_n1, y_n1, z_n1, u_n1, v_n1,
w_n1] = ver.Calculate(G, x_n, y_n, z_n, u_n, v_n, w_n, m_n,
timer_step)
elif (mytype == 2):
print('Threads')
[x_n1, y_n1, z_n1, u_n1, v_n1,
w_n1] = mul.Calculate(G, x_n, y_n, z_n, u_n, v_n, w_n, m_n,
timer_step)
elif (mytype == 3):
print('OpenCL')
#[x_n1, y_n1, z_n1, u_n1, v_n1, w_n1] = ocl.Calculate(G, x_n, y_n, z_n, u_n, v_n, w_n, m_n, timer_step)
else:
print('Cython')
#[x_n1, y_n1, z_n1, u_n1, v_n1, w_n1] = cyt.Calculate(G, x_n, y_n, z_n, u_n, v_n, w_n, m_n, timer_step)
for i in range(length):
position = myClass.Position(x_n1[i] / constRadius,
y_n1[i] / constRadius,
z_n1[i] / constRadius)
velocity = myClass.Velocity(u_n1[i], v_n1[i], w_n1[i])
_particle_list.append(
myClass.Particle(position, velocity, m_n[i] / constMass,
col_n[i]))
return _particle_list
def test_address_find(self):
system = classes.System(width=500., height=200., cell_length=2.)
system.add_particle(classes.Particle())
system.particles[0].state[:2] = [1.4, 1.2]
self.assertEqual([0, 0], system.particles[0].cell_address())
system.particles[0].state[:2] = [201.4, 1.2]
self.assertEqual([100, 0], system.particles[0].cell_address())
system.particles[0].state[:2] = [15.4, 11.2]
self.assertEqual([7, 5], system.particles[0].cell_address())
def system_with_density(system, density):
area = system.area()
particle_quantity = int(area * density)
for part_id in range(particle_quantity):
state = numpy.zeros(4)
x_val = random.random() * system.width
y_val = random.random() * (
system.height - 2 * system.buffer_width) + system.buffer_width
state[:2] = [x_val, y_val]
system.add_particle(classes.Particle(state=state))
def test_confinement_over_time(self):
self.system.add_particle(classes.Particle())
y_0 = 1.0
self.system.particles[0].state[1] = y_0
self.system.particles[1].state[1] = self.system.height - y_0
for i in range(100):
self.system.time_step()
self.assertTrue(y_0 < self.system.particles[0].state[1])
self.assertTrue(
self.system.height - y_0 > self.system.particles[1].state[1])
def combobox_numberChoice(self):
self.timer.stop()
global _particle_list
self.zoom = 1000
self.groupBox_4.setEnabled(False)
rang = 0
if self.comboBox.currentIndex() == 4:
rang = 1000
elif self.comboBox.currentIndex() == 1:
rang = 100
elif self.comboBox.currentIndex() == 2:
rang = 200
elif self.comboBox.currentIndex() == 3:
rang = 400
else:
rang = 3
self.groupBox_4.setEnabled(True)
_particle_list = []
_particle_list.append(
myClass.Particle(myClass.Position(0, 0, 0),
myClass.Velocity(0, 0, 0), 3000, [255, 0, 0]))
for i in range(1, rang):
_particle_list.append(
myClass.Particle(
myClass.Position(random.randint(-500, 500),
random.randint(-500, 500),
random.randint(-500, 500)),
myClass.Velocity(
random.randint(-5, 5) / 10000.0,
random.randint(-5, 5) / 10000.0,
random.randint(-5, 5) / 10000.0),
random.uniform(100, 1000), [
random.uniform(0.3, 0.9),
random.uniform(0.3, 0.9),
random.uniform(0.3, 0.9)
]))
self.timer.start(self._dt)
self.openGLWidget.update()
def test_interaction_force(self):
particle = classes.Particle()
force = particle.interaction_force(self.random4vec_1,
self.random4vec_2)
seperation = particle.sepVec(self.random4vec_1, self.random4vec_2)
sep_angle = numpy.arctan2(seperation[0], seperation[1])
force_angle = numpy.arctan2(force[2], force[3])
self.assertTrue(abs(sep_angle - force_angle) < 10.**-3)
force2 = particle.interaction_force(2 * self.random4vec_1,
2 * self.random4vec_2)
self.assertTrue(numpy.linalg.norm(force) > numpy.linalg.norm(force2))
def setUp(self):
self.random4vec_1 = numpy.array(
[random.random() * 4. - 2. for i in range(4)])
self.random4vec_2 = numpy.array(
[random.random() * 4. - 2. for i in range(4)])
self.system = classes.System(width=500,
height=200,
buffer_width=10,
drag_coeff=.01,
step_size=0.01,
cell_length=2.)
self.system.add_particle(classes.Particle())
def test_interaction_over_time(self):
self.system.add_particle(classes.Particle())
self.system.particles[0].state[:2] = [20.0, 100.0]
self.system.particles[1].state[:2] = (
self.system.particles[0].state[:2] + self.random4vec_1[:2] / 2)
sep_init = self.system.particles[0].sepVec(
self.system.particles[0].state, self.system.particles[1].state)
for i in range(100):
self.system.time_step()
sep_final = self.system.particles[0].sepVec(
self.system.particles[0].state, self.system.particles[1].state)
self.assertTrue(
numpy.linalg.norm(sep_final) > numpy.linalg.norm(sep_init))
def button_add(self):
global _particle_list
x = float(self.textEdit.toPlainText())
y = float(self.textEdit_2.toPlainText())
z = float(self.textEdit_3.toPlainText())
emitter = myClass.Position(x, y, z)
u = float(self.textEdit_4.toPlainText()) / 1000.0
v = float(self.textEdit_5.toPlainText()) / 1000.0
w = float(self.textEdit_6.toPlainText()) / 1000.0
velocity = myClass.Velocity(u, v, w)
_particle_list.append(
myClass.Particle(emitter, velocity, self._m,
self._color.getRgbF()))
self.openGLWidget.update()
def calculateSolar(self):
G = 6.67408 * (10**-11)
self._dt = 100000
timerStep = self._dt
global _particle_list
constRadius = 14959787070
constMass = 5.9726 * 10**24
x_n = [p.x * constRadius for p in _particle_list]
y_n = [p.y * constRadius for p in _particle_list]
z_n = [p.z * constRadius for p in _particle_list]
position = [
myClass.Position(x, y, z) for x, y, z in zip(x_n, y_n, z_n)
]
u_n = [p.u for p in _particle_list]
v_n = [p.v for p in _particle_list]
w_n = [p.w for p in _particle_list]
m_n = [p.m * constMass for p in _particle_list]
col_n = [p.color for p in _particle_list]
length = len(x_n)
if length < 9:
print('stop')
self.timer.stop()
ax_n = []
ay_n = []
az_n = []
for px, py, pz in zip(x_n, y_n, z_n):
part = myClass.Position(px, py, pz)
ax = [
G * m * (p.x - px) / part.Module(p)**3
for p, m in zip(position, m_n) if part.Module(p) > 0
]
ax_n.append(sum(ax))
ay = [
G * m * (p.y - py) / part.Module(p)**3
for p, m in zip(position, m_n) if part.Module(p) > 0
]
ay_n.append(sum(ay))
az = [
G * m * (p.z - pz) / part.Module(p)**3
for p, m in zip(position, m_n) if part.Module(p) > 0
]
az_n.append(sum(az))
x_n1 = [
x + u * timerStep + 0.5 * a * timerStep**2
for x, u, a in zip(x_n, u_n, ax_n)
]
y_n1 = [
y + v * timerStep + 0.5 * a * timerStep**2
for y, v, a in zip(y_n, v_n, ay_n)
]
z_n1 = [
z + w * timerStep + 0.5 * a * timerStep**2
for z, w, a in zip(z_n, w_n, az_n)
]
ax_n1 = []
ay_n1 = []
az_n1 = []
for px, py, pz in zip(x_n1, y_n1, z_n1):
part = myClass.Position(px, py, pz)
ax = []
ay = []
az = []
for x, y, z, m in zip(x_n1, y_n1, z_n1, m_n):
p = myClass.Position(x, y, z)
module = part.Module(p)**3
if module > 0:
ax.append(G * m * (x - px) / module)
ay.append(G * m * (y - py) / module)
az.append(G * m * (z - pz) / module)
ax_n1.append(sum(ax))
ay_n1.append(sum(ay))
az_n1.append(sum(az))
u_n1 = [
u + 0.5 * (an + an1) * timerStep
for u, an, an1 in zip(u_n, ax_n, ax_n1)
]
v_n1 = [
v + 0.5 * (an + an1) * timerStep
for v, an, an1 in zip(v_n, ay_n, ay_n1)
]
w_n1 = [
w + 0.5 * (an + an1) * timerStep
for w, an, an1 in zip(w_n, az_n, az_n1)
]
_particle_list = []
for i in range(length):
position = myClass.Position(x_n1[i] / constRadius,
y_n1[i] / constRadius,
z_n1[i] / constRadius)
velocity = myClass.Velocity(u_n1[i], v_n1[i], w_n1[i])
_particle_list.append(
myClass.Particle(position, velocity, m_n[i] / constMass,
col_n[i]))
if (self.timer.isActive()):
self.openGLWidget.update()
def calculateParticles(self):
G = 6.67408 * (10**-9)
self._dt = 5000
timerStep = self._dt
global _particle_list
x_n = []
y_n = []
z_n = []
u_n = []
v_n = []
w_n = []
m_n = []
col_n = []
for partic in _particle_list:
for par in _particle_list:
if (partic.position.Module(par.position) >
0) & (partic.position.Module(par.position) <
(partic.m + par.m) / 100.0):
if partic.m > par.m:
partic.m += par.m
else:
partic.alive = False
if (partic.alive):
x_n.append(partic.x)
y_n.append(partic.y)
z_n.append(partic.z)
u_n.append(partic.u)
v_n.append(partic.v)
w_n.append(partic.w)
m_n.append(partic.m)
col_n.append(partic.color)
length = len(x_n)
if length < 2:
print('stop')
self.timer.stop()
ax_n = []
ay_n = []
az_n = []
for px, py, pz in zip(x_n, y_n, z_n):
part = myClass.Position(px, py, pz)
ax = []
ay = []
az = []
for p in _particle_list:
module = part.Module(p.position)**3
if module > 0:
ax.append(G * p.m * (p.x - px) / module)
ay.append(G * p.m * (p.y - py) / module)
az.append(G * p.m * (p.z - pz) / module)
ax_n.append(sum(ax))
ay_n.append(sum(ay))
az_n.append(sum(az))
x_n1 = [
x + u * timerStep + 0.5 * a * timerStep**2
for x, u, a in zip(x_n, u_n, ax_n)
]
y_n1 = [
y + v * timerStep + 0.5 * a * timerStep**2
for y, v, a in zip(y_n, v_n, ay_n)
]
z_n1 = [
z + w * timerStep + 0.5 * a * timerStep**2
for z, w, a in zip(z_n, w_n, az_n)
]
ax_n1 = []
ay_n1 = []
az_n1 = []
for px, py, pz in zip(x_n1, y_n1, z_n1):
part = myClass.Position(px, py, pz)
ax = []
ay = []
az = []
for x, y, z, m in zip(x_n1, y_n1, z_n1, m_n):
p = myClass.Position(x, y, z)
module = part.Module(p)**3
if module > 0:
ax.append(G * m * (x - px) / module)
ay.append(G * m * (y - py) / module)
az.append(G * m * (z - pz) / module)
ax_n1.append(sum(ax))
ay_n1.append(sum(ay))
az_n1.append(sum(az))
u_n1 = [
u + 0.5 * (an + an1) * timerStep
for u, an, an1 in zip(u_n, ax_n, ax_n1)
]
v_n1 = [
v + 0.5 * (an + an1) * timerStep
for v, an, an1 in zip(v_n, ay_n, ay_n1)
]
w_n1 = [
w + 0.5 * (an + an1) * timerStep
for w, an, an1 in zip(w_n, az_n, az_n1)
]
_particle_list = []
for i in range(length):
position = myClass.Position(x_n1[i], y_n1[i], z_n1[i])
velocity = myClass.Velocity(u_n1[i], v_n1[i], w_n1[i])
_particle_list.append(
myClass.Particle(position, velocity, m_n[i], col_n[i]))
if (self.timer.isActive()):
self.openGLWidget.update()
def test_seperation_calc(self):
particle = classes.Particle()
seperation = particle.sepVec(self.random4vec_1, self.random4vec_2)
self.assertEqual(2, len(seperation))
deltax = self.random4vec_1[0] - self.random4vec_2[0]
self.assertEqual(deltax, seperation[0])
## ALpha Centauri A p0 = [0.0, 0.0,0.0] #UA v0 = [0.0, 0.0,0.0] #m/s m = 1.432 #masas solares ## ALpha Centauri B p1 = [11.2, 0.0,0.0] #UA v1 = [0., 9.8402e-7,0.0] #km/seg m1 = 1.387 #masas solares dt = .1 #sec lenTime=3600*24*9.604559 #sec n_steps = int(lenTime/dt) A = classes.Particle(p0, v0, m) B = classes.Particle(p1, v1, m1) particles = [A, B] twoBody= classes.Potencial(particles, dt) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') skip = 0 save = False for t in tqdm(range(1,n_steps)): if skip == 1000: skip = 0 save = True system = twoBody.integrate(float(t)*dt, save)
def Calculate(mytype, particle_list, timer_step):
G = 6.67408 * (10**-9)
times = []
for i in range(5):
x_n = []
y_n = []
z_n = []
u_n = []
v_n = []
w_n = []
m_n = []
col_n = []
for partic in particle_list:
for par in particle_list:
if (partic.position.Module(par.position) >
0) & (partic.position.Module(par.position) <
(partic.m + par.m) / 100.0):
if partic.m > par.m:
partic.m += par.m
else:
partic.alive = False
if (partic.alive):
x_n.append(partic.x)
y_n.append(partic.y)
z_n.append(partic.z)
u_n.append(partic.u)
v_n.append(partic.v)
w_n.append(partic.w)
m_n.append(partic.m)
col_n.append(partic.color)
length = len(x_n)
_particle_list = []
if length < 2:
print('stop')
else:
x_n1 = []
y_n1 = []
z_n1 = []
u_n1 = []
v_n1 = []
w_n1 = []
start_time = time.time()
if (mytype == 0):
print('Odeint')
[x_n1, y_n1, z_n1, u_n1, v_n1,
w_n1] = CalculateOdeint(G, x_n, y_n, z_n, u_n, v_n, w_n, m_n,
timer_step)
elif (mytype == 1):
print('Verlet')
[x_n1, y_n1, z_n1, u_n1, v_n1,
w_n1] = ver.Calculate(G, x_n, y_n, z_n, u_n, v_n, w_n, m_n,
timer_step)
elif (mytype == 2):
print('Threads')
[x_n1, y_n1, z_n1, u_n1, v_n1,
w_n1] = mul.Calculate(G, x_n, y_n, z_n, u_n, v_n, w_n, m_n,
timer_step)
elif (mytype == 3):
print('OpenCL')
#[x_n1, y_n1, z_n1, u_n1, v_n1, w_n1] = ocl.Calculate(G, x_n, y_n, z_n, u_n, v_n, w_n, m_n, timer_step)
else:
print('Cython')
#[x_n1, y_n1, z_n1, u_n1, v_n1, w_n1] = cyt.Calculate(G, x_n, y_n, z_n, u_n, v_n, w_n, m_n, timer_step)
times.append(time.time() - start_time)
for i in range(length):
position = myClass.Position(x_n1[i], y_n1[i], z_n1[i])
velocity = myClass.Velocity(u_n1[i], v_n1[i], w_n1[i])
_particle_list.append(
myClass.Particle(position, velocity, m_n[i], col_n[i]))
return times
def load_state_from_file(system, file_address):
states = load_data(file_address)
for state_in in states:
state = numpy.zeros(4)
state[:] = state_in
system.add_particle(classes.Particle(state=state))
pygame.init()
myfont = pygame.font.SysFont('timesnewroman', 12)
pygame.display.set_caption('pygame particle library')
screen = pygame.display.set_mode((screen_size[0], screen_size[1]))
screen.fill(white)
#STATES
mouse_down = False
#OBJECTS
project_name_label = ui.Label(10, 10, "particles")
timer_label = ui.Label(10, 25, "timer label")
emmiter = pt.Emmiter((800, 450), pt.Particle((800, 450)))
#ARRAYS
ui_arr = [project_name_label, timer_label]
particle_array = []
#FUNCTIONS
def spawn_particles(amount, pos, radius):
x, y = pos
for i in range(amount):
x1 = radius * math.sin(i * (2.0 * 3.14) / amount) + x
y1 = radius * math.cos(i * (2.0 * 3.14) / amount) + y
particle_array.append(pt.Particle((x1, y1)))
mapview_width = 0
window = pygame.display.set_mode((mapview_width + scr_width, scr_height + 20))
pygame.display.set_caption("Display Window")
logging.debug('Initiated pygame window. Dimensions: %dx%d.' %
pygame.display.get_surface().get_size())
clock = pygame.time.Clock()
pygame.font.init()
textspace = pygame.font.SysFont("Fira Code", 14)
scene = []
show_map = False
is_active = True
cam = cl.Particle(pos=map.spawn, fov=args.fov, res=args.res)
logging.debug('Initiated player camera.')
w = scr_width / (cam.fov * cam.res)
tbuih = scr_height * cam.fov
half = scr_height / 2
pitch = 0
bounce = 0
b_change = 2
b_limit = 10
movement_speed = 3
moveb_mult = 0.66
cam.rotate(-(3.145 / 2))
paused = False
while is_active:
space.move_particles(particles, particle, focal, ite, [particles.index(particle)-1,particles.index(particle)-len(particles)+1], N_INTERATIONS) for func in FUNCTIONS: for topology in TOPOLOGIES: for w_variation in W_VARIATION: for simulacoes in range(0,N_SIMULATIONS): print(func, topology, w_variation, simulacoes) space = classes.Space(D, c1, c2, func, w_variation, topology) particles = [classes.Particle(space) for i in range (0,N)] focal = classes.Particle(space) FITNESS_VALUES=[] for ite in range(0, N_INTERATIONS): main(particles, space, focal) FITNESS_VALUES.append(space.gbest_value) #print space.gbest_value FITNESS_SIMULACOES_ITE[topology][func].append(np.array(FITNESS_VALUES)) FITNESS_SIMULACOES_FUNC[topology][func].append(space.gbest_value) AVERAGE_FITNESS_SIMULACOES_ITE[topology][func] = np.sum(FITNESS_SIMULACOES_ITE[topology][func], axis=0)/N_SIMULATIONS
def spawn_particles(amount, pos, radius):
x, y = pos
for i in range(amount):
x1 = radius * math.sin(i * (2.0 * 3.14) / amount) + x
y1 = radius * math.cos(i * (2.0 * 3.14) / amount) + y
particle_array.append(pt.Particle((x1, y1)))
import classes as myClass
import calculations as calc
mytype = 1
rang = 100
_dt = 1000
isSolar = True
_particle_list = []
if isSolar:
#Sun
_particle_list.append(myClass.Particle(myClass.Position(0, 0, 0), myClass.Velocity(0, 0, 0), 332900, [1, 0.8, 0]))
#Mercury
_particle_list.append(myClass.Particle(myClass.Position(3.87, 0, 0), myClass.Velocity(0, 47360, 0), 0.055, [0.7, 0.6, 0.6]))
#Venus
_particle_list.append(myClass.Particle(myClass.Position(7.233, 0, 0), myClass.Velocity(0, 35020, 0), 0.815, [0.9, 0.8, 0.7]))
#Earth
_particle_list.append(myClass.Particle(myClass.Position(10, 0, 0), myClass.Velocity(0, 29783, 0), 1, [0.4, 0.6, 0.8]))
#Mars
_particle_list.append(myClass.Particle(myClass.Position(15.24, 0, 0), myClass.Velocity(0, 24100, 0), 0.107, [1, 0.5, 0]))
#Jupiter
_particle_list.append(myClass.Particle(myClass.Position(52, 0, 0), myClass.Velocity(0, 13070, 0), 318, [1, 0.8, 0.6]))
#Saturn
_particle_list.append(myClass.Particle(myClass.Position(100, 0, 0), myClass.Velocity(0, 9690, 0), 95, [0.8, 0.7, 0.1]))
#Uran
_particle_list.append(myClass.Particle(myClass.Position(192.3, 0, 0), myClass.Velocity(0, 6810, 0), 14.6, [0.6, 0.65, 1]))
#Neptune
