def test3(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun,
149.5e6 | units.km)
instance = Huayno(convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 0.00001 | units.AU**2
stars = datamodel.Stars(2)
star1 = stars[0]
star2 = stars[1]
star1.mass = units.MSun(1.0)
star1.position = units.AU(numpy.array((-1.0, 0.0, 0.0)))
star1.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star1.radius = units.RSun(1.0)
star2.mass = units.MSun(1.0)
star2.position = units.AU(numpy.array((1.0, 0.0, 0.0)))
star2.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star2.radius = units.RSun(100.0)
instance.particles.add_particles(stars)
for x in range(1, 2000, 10):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
stars.savepoint()
def plottillagb():
sse = SSEWithMassEvolve()
sse.commit_parameters()
sun, planets = Solarsystem.new_solarsystem()
sse.particles.add_particles(sun)
sse.commit_particles()
channel = sse.particles.new_channel_to(sun)
channel.copy()
massrange = units.MSun(numpy.arange(1, 0.8, -0.001))
print massrange
masses = [] | units.MSun
timerange = [] | units.Myr
for mass in massrange:
#sse.evolve_model(time)
sse.evolve_mass(mass)
timerange.append(sse.evolve_mass(mass))
channel.copy()
masses.append(sse.particles[0].mass)
#print time.value_in(units.yr), sse.particles[0].mass.value_in(units.MSun)
sse.stop()
plot(massrange, timerange, '.')
native_plot.show()
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 test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun,
149.5e6 | units.km)
instance = BHTree(convert_nbody)
instance.parameters.epsilon_squared = 0.001 | units.AU**2
stars = datamodel.Stars(2)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = [0.0, 0.0, 0.0] | units.m
sun.velocity = [0.0, 0.0, 0.0] | units.ms
sun.radius = units.RSun(1.0)
earth = stars[1]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = [149.5e6, 0.0, 0.0] | units.km
earth.velocity = [0.0, 29800, 0.0] | units.ms
#instance.particles.add_particles(stars)
instance.particles.add_particles(stars)
postion_at_start = earth.position.value_in(units.AU)[0]
instance.evolve_model(365.0 | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
postion_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(postion_at_start, postion_after_full_rotation,
3)
instance.evolve_model(365.0 + (365.0 / 2) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
postion_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-postion_at_start,
postion_after_half_a_rotation, 2)
instance.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
postion_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-postion_at_start,
postion_after_half_a_rotation, 1)
instance.cleanup_code()
instance.stop()
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 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 test3(self):
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)
star1 = stars[0]
star2 = stars[1]
star1.mass = units.MSun(1.0)
star1.position = units.AU(numpy.array((-.10, 0.0, 0.0)))
star1.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star1.radius = units.RSun(1.0)
star2.mass = units.MSun(1.0)
star2.position = units.AU(numpy.array((.10, 0.0, 0.0)))
star2.velocity = units.AUd(numpy.array((0.0, 0.0, 0.0)))
star2.radius = units.RSun(100.0)
instance.particles.add_particles(stars)
instance.commit_particles()
for x in range(1, 200, 1):
instance.evolve_model(x | units.day)
instance.particles.copy_values_of_all_attributes_to(stars)
#instance.get_indices_of_colliding_particles()
#print stars[0].position-stars[1].position
stars.savepoint()
instance.cleanup_code()
instance.stop()
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 polyevolve():
sun, planets = Solarsystem.new_solarsystem()
gd, se = setup_codes(sun, planets)
channelp = gd.orbiters.new_channel_to(planets)
channels = se.particles.new_channel_to(sun)
prev_mass = sun[0].mass
massrange = units.MSun(numpy.arange(0.9, 0.89999, -1e-9))
masses = [] | units.MSun
timerange = [] | units.Myr
for i, mass in enumerate(massrange):
time, dummymass = se.evolve_mass(mass)
if i == 0:
initialtime = time
print(time, mass, "evolving gd")
gdtime = time - initialtime
print(gdtime)
err = gd.evolve_model(gdtime)
channelp.copy()
planets.savepoint(time)
channels.copy()
gd.central_particle.mass = sun[0].mass
print(sun[0].mass)
print(
sun[0].mass.value_in(units.MSun),
time.value_in(units.Myr),
planets[4].x.value_in(units.AU),
planets[4].y.value_in(units.AU),
planets[4].z.value_in(units.AU),
)
gd.stop()
se.stop()
for planet in planets:
t, x = planet.get_timeline_of_attribute_as_vector("x")
t, y = planet.get_timeline_of_attribute_as_vector("y")
t, z = planet.get_timeline_of_attribute_as_vector("z")
plot3(x, y, z, '.')
native_plot.gca().set_aspect('equal')
native_plot.show()
def unit_str_to_quantity(s):
s_split = s.split(" ")
if len(s_split) == 2:
raw_value, unit = s_split
elif len(s_split) == 3:
# e.g. '100000 10^10 MSol'
raw_value, factor, unit = s_split
try:
# e.g. '3.08568e+21 cm'
value, power = raw_value.split("e")
value = float(value) * 10**int(power)
except ValueError as e:
# Has no "e+" throws "need more than 1 value to unpack"
if e.message != "need more than 1 value to unpack":
raise
# print "Warning! ValueError", e, "occurred for unit:", raw_value, unit
value = float(raw_value)
if unit == "cm":
return units.cm(value)
elif unit == "sec":
return units.s(value)
elif unit == "g":
return units.g(value)
elif unit == "cm/s":
return value | units.cm / units.g
elif unit == "g/cm^3":
return value | units.g / units.cm**3
elif unit == "erg":
return units.erg(value)
elif unit == "kpc":
return units.kpc(value)
elif unit == "km/s":
return value | units.km / units.s
elif unit == "MSol" or unit == "Msol":
if factor != "10^10":
raise ValueError("incorrect mass factor parsed. value={0}, factor={1}, unit={2}"\
.format(value, factor, unit))
code_unit_mass = 1e10
return units.MSun(value * code_unit_mass)
else:
print "Error: Unit not defined. Add it :-)"
raise ValueError("unknown unit given. value={0}, factor={1}, unit={2}"\
.format(value, factor, unit))
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 testsse():
sse = SSEWithMassEvolve()
sse.commit_parameters()
sun, planets = new_solar_system_for_mercury()
sse.particles.add_particles(sun)
sse.commit_particles()
channel = sse.particles.new_channel_to(sun)
channel.copy()
massrange = units.MSun(numpy.arange(1, 0.8, -0.001))
masses = [] | units.MSun
timerange = [] | units.Myr
for mass in massrange:
sse.evolve_mass(mass)
t, m = sse.evolve_mass(mass)
timerange.append(t)
channel.copy()
masses.append(sse.particles[0].mass)
sse.stop()
plot(massrange, timerange, '.')
native_plot.show()
def simulate_massloss(time):
return units.MSun(0.5*(1.0+1.0/(1.0+numpy.exp((time.value_in(time.unit)-70.0)/15.))))
def setup_solar_system(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
stars = datamodel.Stars(8)
sun = stars[0]
sun.mass = units.MSun(1.0)
sun.position = units.AU(array((0.0,0.0,0.0)))
sun.velocity = units.AUd(array((0.0,0.0,0.0)))
sun.radius = units.RSun(1.0)
mercury = stars[1]
mercury.mass = units.kg( 3.302e23)
mercury.radius = units.km(2440)
mercury.position = units.AU(array((-1.812507519383936E-01, -4.238556570722329E-01, -1.858336536398257E-02)))
mercury.velocity = units.AUd(array((2.028905659997442E-02, -9.482619060967475E-03, -2.636707283074494E-03)))
venus = stars[2]
venus.mass = units.kg(48.685e23)
venus.radius = units.km(6051.8)
venus.position = units.AU(array((7.174859394658725E-01, -9.118094489213757E-02, -4.286369239375957E-02)))
venus.velocity = units.AUd(array((2.569149540621095E-03, 1.995467986481682E-02, 1.246915402703626E-04)))
earth = stars[3]
earth.mass = units.kg(5.9736e24)
earth.radius = units.km(6371)
earth.position = units.AU(array(( 4.152751345538410E-01, 8.988236789078493E-01, -4.821560120168533E-05)))
earth.velocity = units.AUd(array(( -1.588315644843389E-02, 7.210443860976745E-03, -1.350251461569625E-07)))
moon = stars[4]
moon.mass = units.kg(7.35e22)
moon.radius = units.km(1738)
moon.position = units.AU(array(( 4.138191074397691E-01, 8.965602570292573E-01, -2.762446418149536E-04)))
moon.velocity = units.AUd(array(( -1.541527312550390E-02, 6.894586206029982E-03, 1.223837010915995E-05)))
mars = stars[5]
mars.mass = units.kg(6.4185e23)
mars.radius = units.km(3389.9)
mars.position = units.AU(array(( -5.350147323170708E-01, -1.400272441929516E+00, -1.637545552747233E-02)))
mars.velocity = units.AUd(array(( 1.360625065710822E-02, -3.765876077406818E-03, -4.130340644254660E-04)))
jupiter = stars[6]
jupiter.mass = units.kg(1898.13e24)
jupiter.radius = units.km(71492)
jupiter.position = units.AU(array(( 2.503092399973117E+00, -4.468134118102924E+00, -3.752173268244928E-02)))
jupiter.velocity = units.AUd(array(( 6.490840561446090E-03, 4.046895067472646E-03, -1.620422227298534E-04)))
saturn = stars[7]
saturn.mass = units.kg(5.68319e26 )
saturn.radius = units.km(58232)
saturn.position = units.AU(array(( -9.023156820924056E+00, 2.468810475231705E+00, 3.161126539154331E-01)))
saturn.velocity = units.AUd(array(( -1.769097295887704E-03, -5.393257979873611E-03, 1.639859191780030E-04 )))
dist = earth.position - moon.position
print "distance vector"+str(dist)
print "distance %s\n" % (dot(dist,dist)**0.5).as_quantity_in(units.m)#(dist*dist).sum()**0.5
velo = moon.velocity-earth.velocity
print "orb velocity %s\n" % (dot(velo,velo)**0.5).as_quantity_in(units.m/units.s)
return stars
tend = self.model_time
if tend > self.mech_time:
dt = tend - self.mech_time
self.mech_time = tend
lm = lmech(self.particles)
self.particles.Lmech = lm.copy()
self.particles.Emech=self.particles.Emech+dt*(prev_lm+lm)/2. + \
e_supernova(self.particles.stellar_type,stellar_type)
return ret
if __name__ == "__main__":
evo = SSEplus()
evo.initialize_module_with_default_parameters()
p = datamodel.Particles(4)
p.mass = units.MSun([15., 25., 35., 50.])
evo.particles.add_particles(p)
t = zero
while t < 1 | units.Myr:
t += .125 | units.Myr
evo.evolve_model(t)
print evo.particles.Emech.in_(1.e51 * units.erg)
print evo.model_time
parts = evo.particles.copy()
evo2 = SSEplus()
evo2.initialize_module_with_default_parameters()
evo2.particles.add_particles(parts)
