def test_reset_just_moved(self):
position = Position()
particle = Particle("R")
position.add_particle(particle)
position.particles[0].is_just_moved = True
position.reset_just_moved()
self.assertEqual(position.particles[0].is_just_moved, False)
def generate_particles(self, number_of_new_particles):
"""Create a new particle at the generator's location and give it an initial velocity"""
# In the callback case the implementer controls it all, including the number
# create an empty list to hold the data
particle_data = []
if self.callback:
# We have a callback, so delegate all of the work....
particle_data = self.callback()
else:
# No callback, so make some random ones by default
for particle_index in range(0, number_of_new_particles):
new_data = (random.randint(-2, 2), random.randint(5, 20) * -1,
(random.randint(0, 255), random.randint(0, 255),
random.randint(0, 255)))
particle_data.append(new_data)
# Callback or not, at this point we should have a list of particle data
for particle_info in particle_data:
# Create a new particle object
new_particle = Particle(self.screen, self.settings, self.x, self.y,
particle_info[0], particle_info[1],
random.randint(1, 4), particle_info[2])
# Add it to the list to track/draw
self.particles.append(new_particle)
def test_position_is_empty(self):
position = Position()
self.assertEqual(position.particles, [])
self.assertEqual(position.is_empty(), True)
particle = Particle("L")
position.add_particle(particle)
self.assertEqual(position.is_empty(), False)
self.assertEqual(position.particles, [particle])
def __minimize(self,
constFunc,
x0,
bounds,
num_particles,
maxiter,
verbose=False):
err_best_g = -1
pos_best_g = []
swarm = []
for i in range(0, num_particles):
swarm.append(Particle(x0))
i = 0
while i < maxiter:
if verbose:
print(f'iter: {i:>4d}, best solution: {err_best_g:10.6f}')
for j in range(0, num_particles):
swarm[j].evaluate(constFunc)
if swarm[j].err < err_best_g or err_best_g == -1:
pos_best_g = list(swarm[j].position)
err_best_g = float(swarm[j].err)
for j in range(num_particles):
swarm[j].update_velocity(pos_best_g)
swarm[j].update_position(bounds)
i = i + 1
print('\nFINAL SOLUTION:')
print(f' > {pos_best_g}')
print(f' > {err_best_g}\n')
def test_visualize() -> None:
particles = [Particle(0.3, 0.5), Particle(0.0, -0.5), Particle(-0.1, -0.4)]
simulator = Simulator(particles)
visualize(simulator)
def test_remove_particle(self):
position = Position()
particle = Particle("R")
position.add_particle(particle)
position.remove_particle(0)
self.assertEqual(position.is_empty(), True)
def test_particle_creation(self):
particle = Particle("L")
self.assertEqual(particle.direction, "L")
self.assertEqual(particle.is_just_moved, False)
import sys
import matplotlib.pylab as plt
import numpy as np
from os import path
sys.path.append(path.dirname(path.dirname(
path.abspath(__file__)))) # adds src to module list
from src.particle import Particle
from src.particle import Spherical_Plummer_Vectorized
p = Particle([1., 0., 0., 0., 0., 0., 0.], 1.)
p_resample = p.Resample_Plummer_Positions(1000000)
r = [np.linalg.norm(x) for x in p_resample]
bin_edges = np.linspace(-1, 1, 51)
bins = bin_edges[1:] - (bin_edges[1] - bin_edges[0])
x_hist, _ = np.histogram(p_resample.T[0], bins=bin_edges)
y_hist, _ = np.histogram(p_resample.T[1], bins=bin_edges)
z_hist, _ = np.histogram(p_resample.T[2], bins=bin_edges)
r_bin_edges = np.linspace(0, 10., 101)
r_bins = r_bin_edges[1:] - (r_bin_edges[1] - r_bin_edges[0])
r_hist, _ = np.histogram(r, bins=r_bin_edges, normed=True)
plt.plot(r_bins, r_hist)
plt.plot(r_bins, Spherical_Plummer_Vectorized(r_bins, 1))
plt.show()
plt.plot(bins, x_hist, lw=2)