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