def test1(self):
class Code(object):
def __init__(self):
# x,y,z,mass
self.data = []
self.get_position_called = False
self.set_position_called = False
def get_number_of_particles(self):
return 0 if not self.data else len(self.data[0])
def get_position(self,index):
self.get_position_called = True
data_to_return = [(self.data[0][i], self.data[1][i], self.data[2][i]) for i in index]
data_to_return = numpy.asarray(data_to_return).reshape(3,-1)
return [units.m(x) for x in data_to_return]
def set_position(self,index,x,y,z):
self.set_position_called = True
pass
def new_particle(self, x, y, z):
x = x.value_in(units.m)
y = y.value_in(units.m)
z = z.value_in(units.m)
self.data = [x,y,z]
return [i for i in range(len(x))]
code = Code()
storage = InCodeAttributeStorage(
code,
NewParticleMethod(code.new_particle,("x","y","z")),
None,
code.get_number_of_particles,
[],
[ParticleGetAttributesMethod(code.get_position,("x","y","z")),],
name_of_the_index = "index"
)
self.assertEquals(len(storage), 0)
self.assertEquals(storage.get_defined_attribute_names(), ["x","y","z"])
self.assertFalse(code.get_position_called)
storage.get_values_in_store([],["x","y","z"])
self.assertFalse(code.get_position_called)
storage.add_particles_to_store(
[1,2,3,4],
["x","y","z"],
[
units.m([1,2,3,4]),
units.m([2,3,4,5]),
units.m([3,4,5,6])
]
)
self.assertEquals(len(storage), 4)
def test1(self):
class Code(object):
def __init__(self):
# x,y,z,mass
self.data = []
self.get_position_called = False
self.set_position_called = False
def get_number_of_particles(self):
return 0 if not self.data else len(self.data[0])
def get_position(self, index):
self.get_position_called = True
data_to_return = [(self.data[0][i], self.data[1][i],
self.data[2][i]) for i in index]
data_to_return = numpy.asarray(data_to_return).reshape(3, -1)
return [units.m(x) for x in data_to_return]
def set_position(self, index, x, y, z):
self.set_position_called = True
pass
def new_particle(self, x, y, z):
x = x.value_in(units.m)
y = y.value_in(units.m)
z = z.value_in(units.m)
self.data = [x, y, z]
return [i for i in range(len(x))]
code = Code()
storage = InCodeAttributeStorage(
code,
NewParticleMethod(code.new_particle, ("x", "y", "z")),
None,
code.get_number_of_particles, [], [
ParticleGetAttributesMethod(code.get_position,
("x", "y", "z")),
],
name_of_the_index="index")
self.assertEquals(len(storage), 0)
self.assertEquals(storage.get_defined_attribute_names(),
["x", "y", "z"])
self.assertFalse(code.get_position_called)
storage.get_values_in_store([], ["x", "y", "z"])
self.assertFalse(code.get_position_called)
storage.add_particles_to_store([1, 2, 3, 4], ["x", "y", "z"], [
units.m([1, 2, 3, 4]),
units.m([2, 3, 4, 5]),
units.m([3, 4, 5, 6])
])
self.assertEquals(len(storage), 4)
def __init__(self):
self.Sun = LoadStar('sun')
self.Sun.mass = units.MSun(1.0)
self.Sun.radius = units.RSun(1.0)
self.Mercury = LoadStar('mercury')
self.Mercury.mass = units.kg(3.302e23)
self.Mercury.radius = units.km(2440)
self.Venus = LoadStar('venus')
self.Venus.mass = units.kg(48.685e23)
self.Venus.radius = units.km(6051.8)
self.Earth = LoadStar('earth')
self.Earth.mass = units.kg(5.9736e24)
self.Earth.radius = units.km(6371)
self.Moon = LoadStar('moon')
self.Moon.mass = units.kg(7.35e22)
self.Moon.radius = units.km(1738)
self.Mars = LoadStar('mars')
self.Mars.mass = units.kg(6.4185e23)
self.Mars.radius = units.km(3389.9)
self.Jupiter = LoadStar('jupiter')
self.Jupiter.mass = units.kg(1898.13e24)
self.Jupiter.radius = units.km(71492)
#self.Jupiter.radius = units.km(0.000001)
self.Saturn = LoadStar('saturn')
self.Saturn.mass = units.kg(5.68319e26)
self.Saturn.radius = units.km(58232)
self.Uranus = LoadStar('uranus')
self.Uranus.mass = units.kg(86.8103e24)
self.Uranus.radius = units.km(26000)
self.Neptune = LoadStar('neptune')
self.Neptune.mass = units.kg(102.41e24)
self.Neptune.radius = units.km(25000)
self.VoyagerI = LoadStar('voyagerI')
self.VoyagerI.mass = units.kg(500)
self.VoyagerI.radius = units.m(20)
self.VoyagerII = LoadStar('voyagerII')
self.VoyagerII.mass = units.kg(1000)
self.VoyagerII.radius = units.m(20)
def setup_particle_system(n_dust):
stars = datamodel.Stars(n_dust)
generate_dust(stars)
sun = stars[0]
sun.mass = 1.0 | units.MSun
sun.position = units.m(np.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(np.array((0.0, 0.0, 0.0)))
sun.radius = 0.1000 | units.RSun
#earth = stars[1]
#earth.mass = units.kg(5.9736e24)
#earth.position = units.AU(np.array((8.418982185410142E-01, 5.355823303978186E-01, 2.327960005926782E-05)))
#earth.velocity = units.AUd(np.array((-9.488931818313919E-03, 1.447515189957170E-02, 3.617712172296458E-07)))
#earth.radius = 6000 | units.km
jupiter = stars[1]
jupiter.mass = 1.8986e27 | units.kg #
jupiter.position = units.AU(
np.array((-1.443168153922270E+00, -5.114454902835615E+00,
5.340409708180518E-02)))
jupiter.velocity = units.AUd(
np.array((7.173114487727194E-03, -1.699488558889569E-03,
-1.537231526125508E-04)))
jupiter.radius = 20000 | units.km
return stars, sun, jupiter
def test2(self):
#not completed
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun,
149.5e6 | units.km)
instance = BHTree(convert_nbody)
#instance.dt_dia = 1
instance.parameters.epsilon_squared = 0.001 | units.AU**2
#instance.timestep = 0.0001
#instance.use_self_gravity = 0
instance.commit_parameters()
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertAlmostRelativeEquals(sun.radius,
instance.particles[0].radius)
for x in range(1, 2000, 10):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
if HAS_MATPLOTLIB:
figure = pyplot.figure()
plot = figure.add_subplot(1, 1, 1)
x_points = earth.get_timeline_of_attribute("x")
y_points = earth.get_timeline_of_attribute("y")
x_points_in_AU = map(lambda (t, x): x.value_in(units.AU), x_points)
y_points_in_AU = map(lambda (t, x): x.value_in(units.AU), y_points)
plot.scatter(x_points_in_AU, y_points_in_AU, color="b", marker='o')
plot.set_xlim(-1.5, 1.5)
plot.set_ylim(-1.5, 1.5)
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path,
"bhtree-earth-sun.svg")
figure.savefig(output_file)
instance.cleanup_code()
instance.stop()
def test2(self):
#not completed
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
instance = FDPS(convert_nbody)
#instance.dt_dia = 1
instance.parameters.epsilon_squared = 0.001 | units.AU**2
#instance.timestep = 0.0001
#instance.use_self_gravity = 0
instance.commit_parameters()
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0,0.0,0.0)))
sun.velocity = units.ms(numpy.array((0.0,0.0,0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6,0.0,0.0)))
earth.velocity = units.ms(numpy.array((0.0,29800,0.0)))
instance.particles.add_particles(stars)
instance.commit_particles()
self.assertAlmostRelativeEquals(sun.radius, instance.particles[0].radius)
for x in range(1,2000,10):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
if HAS_MATPLOTLIB:
figure = pyplot.figure()
plot = figure.add_subplot(1,1,1)
x_points = earth.get_timeline_of_attribute("x")
y_points = earth.get_timeline_of_attribute("y")
x_points_in_AU = map(lambda (t,x) : x.value_in(units.AU), x_points)
y_points_in_AU = map(lambda (t,x) : x.value_in(units.AU), y_points)
plot.scatter(x_points_in_AU,y_points_in_AU, color = "b", marker = 'o')
plot.set_xlim(-1.5, 1.5)
plot.set_ylim(-1.5, 1.5)
test_results_path = self.get_path_to_results()
output_file = os.path.join(test_results_path, "fdps-earth-sun.svg")
figure.savefig(output_file)
instance.cleanup_code()
instance.stop()
def new_system_sun_and_earth(self):
result = Particles(2)
sun = result[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = result[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
return result
def new_system_sun_and_earth(self):
result = Particles(2)
sun = result[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0,0.0,0.0)))
sun.velocity = units.ms(numpy.array((0.0,0.0,0.0)))
sun.radius = units.RSun(1.0)
earth = result[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6,0.0,0.0)))
earth.velocity = units.ms(numpy.array((0.0,29800,0.0)))
return result
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(np.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(np.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(np.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(np.array((0.0, 29800, 0.0)))
return stars
def new_system_of_sun_and_earth(self):
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0,0.0,0.0)))
sun.velocity = units.ms(numpy.array((0.0,0.0,0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6,0.0,0.0)))
earth.velocity = units.ms(numpy.array((0.0,29800,0.0)))
return stars
def new_system_of_sun_and_earth_and_moon(self):
stars = datamodel.Stars(3)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0, 0.0, 0.0)))
sun.velocity = units.ms(numpy.array((0.0, 0.0, 0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6, 0.0, 0.0)))
earth.velocity = units.ms(numpy.array((0.0, 29800, 0.0)))
moon = stars[2]
moon.mass = units.kg(7.3477e22)
moon.radius = units.km(1737.10)
moon.position = units.km(numpy.array((149.5e6 + 384399.0, 0.0, 0.0)))
moon.velocity = ([0.0, 1.022, 0] | units.km / units.s) + earth.velocity
return stars
def new_system_of_sun_and_earth_and_moon(self):
stars = datamodel.Stars(3)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.m(numpy.array((0.0,0.0,0.0)))
sun.velocity = units.ms(numpy.array((0.0,0.0,0.0)))
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.km(numpy.array((149.5e6,0.0,0.0)))
earth.velocity = units.ms(numpy.array((0.0,29800,0.0)))
moon = stars[2]
moon.mass = units.kg(7.3477e22 )
moon.radius = units.km(1737.10)
moon.position = units.km(numpy.array((149.5e6 + 384399.0 ,0.0,0.0)))
moon.velocity = ([0.0,1.022,0] | units.km/units.s) + earth.velocity
return stars
def get_position(self, index):
self.get_position_called = True
data_to_return = [(self.data[0][i], self.data[1][i],
self.data[2][i]) for i in index]
data_to_return = numpy.asarray(data_to_return).reshape(3, -1)
return [units.m(x) for x in data_to_return]
I.stars[i].velocity = units.AUd(array((v[0], v[1], v[2])))
I.instance.setup_particles(I.stars)
I.model_t0 = date(1971, 10, 26)
I.evolve(date(1971, 10, 26), date(1978, 1, 3),
10) #till voyager launch + some days
voyagers = datamodel.Stars(1)
voyagerI = voyagers[0] #I.stars.new_particle()
#voyagerII = voyagers[1]# I.stars.new_particle()
VoyagerI = LoadStar('voyagerI')
voyagerI.mass = units.kg(1000)
voyagerI.radius = units.m(20)
r, v = VoyagerI.get_vectors_at_date(date(1978, 1, 3))
Jx = I.stars[6].position.x.value_in(units.m)
Jy = I.stars[6].position.y.value_in(units.m)
Jz = I.stars[6].position.z.value_in(units.m)
Jvx = I.stars[6].velocity.x.value_in(units.m / units.s)
Jvy = I.stars[6].velocity.y.value_in(units.m / units.s)
Jvz = I.stars[6].velocity.z.value_in(units.m / units.s)
s = raw_input()
voyagerI.position = units.AU(array((r[0], r[1], r[2])))
voyagerI.velocity = units.AUd(array((v[0], v[1], v[2])))
"""
VoyagerII = LoadStar('voyagerII')
voyagerII.mass = units.kg(1000)
self.omega += 0.05
self.render(R)
if __name__ == "__main__":
nstars = 1 #int(sys.argv[1])
workers = 1 #int(sys.argv[2])
method = 'hermite' # sys.argv[3]
print nstars
seed = None
stars = datamodel.Stars(3)
earth = stars[0]
earth.mass = units.kg(5.9736e24)
earth.position = units.m(np.array((0.0, 0.0, 0.0)))
earth.velocity = units.ms(np.array((0.0, 0.0, 0.0)))
earth.radius = units.km(6371)
sat_one = stars[1]
sat_one.mass = units.kg(1000)
sat_one.radius = units.m(10)
sat_one.position = units.km(np.array((6371 + 242, 0.0, 0.0)))
sat_one.velocity = units.ms(np.array((0.0, 27359 / 3.6, 0.0)))
sat_two = stars[2]
sat_two.mass = units.kg(1000)
sat_two.radius = units.m(10)
sat_two.position = units.km(np.array((6371 + 242, 100.0, 0.0)))
sat_two.velocity = units.ms(np.array((0.0, 27359 / 3.6, 0.0)))
def get_ijk(self, i, j, k, d, l):
return units.m(d), units.m(l), units.m(k)
def test7(self):
class Code(object):
def __init__(self):
# x,y,z,mass
self.data = []
self.get_position_called = False
self.set_position_called = False
self.get_mass_called = False
self.set_mass_called = False
def get_number_of_particles(self):
return 0 if not self.data else len(self.data[0])
def get_position(self, index):
self.get_position_called = True
data_to_return = [(self.data[0][i], self.data[1][i],
self.data[2][i]) for i in index]
data_to_return = numpy.asarray(data_to_return).reshape(3, -1)
return [units.m(x) for x in data_to_return]
def get_mass(self, index):
self.get_mass_called = True
data_to_return = [self.data[3][i] for i in index]
return data_to_return
def set_position(self, index, x, y, z):
self.set_position_called = True
pass
def set_mass(self, index, mass):
self.set_mass_called = True
for i, j in enumerate(index):
self.data[3][j] = mass[i]
return [0 for i in range(len(index))]
def new_particle(self, x, y, z, mass):
x = x.value_in(units.m)
y = y.value_in(units.m)
z = z.value_in(units.m)
mass = mass
self.data = [x, y, z, mass]
return [i for i in range(len(x))]
code = Code()
storage = InCodeAttributeStorage(
code,
NewParticleMethod(code.new_particle, ("x", "y", "z", "mass")),
None,
code.get_number_of_particles, [
ParticleSetAttributesMethod(code.set_position,
("x", "y", "z")),
ParticleSetAttributesMethod(code.set_mass, ("mass", )),
], [
ParticleGetAttributesMethod(code.get_position,
("x", "y", "z")),
ParticleGetAttributesMethod(code.get_mass, ("mass", )),
],
name_of_the_index="index")
storage.add_particles_to_store([1, 2, 3, 4], ["x", "y", "z", "mass"], [
units.m([1, 2, 3, 4]),
units.m([2, 3, 4, 5]),
units.m([3, 4, 5, 6]),
numpy.asarray([13.0, 14.0, 15, 16]),
])
self.assertEquals(len(storage), 4)
self.assertEquals(storage.get_defined_attribute_names(),
["mass", "x", "y", "z"])
self.assertFalse(code.get_position_called)
self.assertFalse(code.get_mass_called)
indices = storage.get_indices_of([2, 3])
x, y, mass = storage.get_values_in_store(indices, ["x", "y", "mass"])
self.assertTrue(code.get_position_called)
self.assertTrue(code.get_mass_called)
self.assertEquals(x[1], 3 | units.m)
self.assertEquals(mass[1], 15)
self.assertEquals(mass[0], 14)
storage.set_values_in_store(indices, ["x", "y", "z", "mass"],
[[10, 11] | units.m, [12, 14] | units.m,
[12, 14] | units.m, [40.0, 50.0]])
x, y, mass = storage.get_values_in_store(indices, ["x", "y", "mass"])
self.assertEquals(mass[1], 50)
self.assertEquals(mass[0], 40)
def get_position(self,index):
self.get_position_called = True
data_to_return = [(self.data[0][i], self.data[1][i], self.data[2][i]) for i in index]
data_to_return = numpy.asarray(data_to_return).reshape(3,-1)
return [units.m(x) for x in data_to_return]
def get_ijk(self,i,j,k):
return units.m(i), units.m(j), units.m(k)
def get_ijk(self,i,j,k, d, l):
return units.m(d), units.m(l), units.m(k)
def test7(self):
class Code(object):
def __init__(self):
# x,y,z,mass
self.data = []
self.get_position_called = False
self.set_position_called = False
self.get_mass_called = False
self.set_mass_called = False
def get_number_of_particles(self):
return 0 if not self.data else len(self.data[0])
def get_position(self,index):
self.get_position_called = True
data_to_return = [(self.data[0][i], self.data[1][i], self.data[2][i]) for i in index]
data_to_return = numpy.asarray(data_to_return).reshape(3,-1)
return [units.m(x) for x in data_to_return]
def get_mass(self,index):
self.get_mass_called = True
data_to_return = [self.data[3][i] for i in index]
return data_to_return
def set_position(self,index,x,y,z):
self.set_position_called = True
pass
def set_mass(self,index,mass):
self.set_mass_called = True
for i,j in enumerate(index):
self.data[3][j] = mass[i]
return [0 for i in range(len(index))]
def new_particle(self, x, y, z, mass):
x = x.value_in(units.m)
y = y.value_in(units.m)
z = z.value_in(units.m)
mass = mass
self.data = [x,y,z,mass]
return [i for i in range(len(x))]
code = Code()
storage = InCodeAttributeStorage(
code,
NewParticleMethod(code.new_particle,("x","y","z","mass")),
None,
code.get_number_of_particles,
[
ParticleSetAttributesMethod(code.set_position,("x","y","z")),
ParticleSetAttributesMethod(code.set_mass,("mass",)),
],
[
ParticleGetAttributesMethod(code.get_position,("x","y","z")),
ParticleGetAttributesMethod(code.get_mass,("mass",)),
],
name_of_the_index = "index"
)
storage.add_particles_to_store(
[1,2,3,4],
["x","y","z", "mass"],
[
units.m([1,2,3,4]),
units.m([2,3,4,5]),
units.m([3,4,5,6]),
numpy.asarray([13.0,14.0,15,16]),
]
)
self.assertEquals(len(storage), 4)
self.assertEquals(storage.get_defined_attribute_names(), [ "mass", "x","y","z"])
self.assertFalse(code.get_position_called)
self.assertFalse(code.get_mass_called)
indices = storage.get_indices_of([2,3])
x,y,mass = storage.get_values_in_store(indices,["x","y","mass"])
self.assertTrue(code.get_position_called)
self.assertTrue(code.get_mass_called)
self.assertEquals(x[1], 3 | units.m)
self.assertEquals(mass[1], 15 )
self.assertEquals(mass[0], 14 )
storage.set_values_in_store(indices,["x","y", "z", "mass"], [[10,11] | units.m , [12,14] | units.m, [12,14] | units.m, [40.0, 50.0]])
x,y,mass = storage.get_values_in_store(indices,["x","y","mass"])
self.assertEquals(mass[1], 50 )
self.assertEquals(mass[0], 40 )
def get_ijk(self, i, j, k):
return units.m(i), units.m(j), units.m(k)
