def test5(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = Huayno(convert_nbody)
instance.initialize_code()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
instance.set_state(1, 16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m,
1.0|units.ms, 1.0|units.ms, 1.0|units.ms)
curr_state = instance.get_state(1)
for expected, actural in zip((16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m,
1.0|units.ms, 1.0|units.ms, 1.0|units.ms, 0 | units.m), curr_state):
self.assertAlmostRelativeEquals(actural,expected)
instance.set_state(1, 16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m,
1.0|units.ms, 1.0|units.ms, 1.0|units.ms , 20.0|units.m)
curr_state = instance.get_state(1)
for expected, actural in zip((16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m,
1.0|units.ms, 1.0|units.ms, 1.0|units.ms, 20 | units.m), curr_state):
self.assertAlmostRelativeEquals(actural,expected)
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 test6(self):
print("Test6: Testing Huayno parameters")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.yr,
1.0 | units.AU)
instance = Huayno(convert_nbody)
(value, error) = instance.legacy_interface.get_eps2()
self.assertEqual(0, error)
self.assertEqual(0.0, value)
self.assertAlmostEqual(0.0 | units.AU**2,
instance.parameters.epsilon_squared,
in_units=units.AU**2)
for x in [0.01, 0.1, 0.2]:
instance.parameters.epsilon_squared = x | units.AU**2
self.assertAlmostEqual(x | units.AU**2,
instance.parameters.epsilon_squared,
in_units=units.AU**2)
(value, error) = instance.legacy_interface.get_time()
self.assertEqual(0, error)
self.assertEqual(0.0, value)
self.assertAlmostEqual(0.0 | units.yr,
instance.parameters.begin_time,
in_units=units.yr)
for x in [1.0, 10.0, 100.0]:
instance.parameters.begin_time = x | units.yr
self.assertAlmostEqual(x | units.yr,
instance.parameters.begin_time,
in_units=units.yr)
instance.stop()
def test16(self):
solsys = new_solar_system()
solsys.x-=1.| units.AU
p=datamodel.Particles(3)
p.mass=[1,2,3] | units.MSun
p.x=[1,10,100] | units.AU
p.y=[0,0,-10] | units.AU
p.z=[0,0,10] | units.AU
from amuse.community.huayno.interface import Huayno
from amuse.units import nbody_system
conv=nbody_system.nbody_to_si(1. | units.AU, 1.| units.MSun)
h = Huayno(conv)
h.particles.add_particles(solsys)
ax1,ay1,az1=h.get_gravity_at_point(p.x*0.,p.x,p.y,p.z)
mercury = Mercury()
mercury.particles.add_particles(solsys)
ax2,ay2,az2=mercury.get_gravity_at_point(p.x*0.,p.x,p.y,p.z)
self.assertAlmostRelativeEqual(ax1,ax2,12)
self.assertAlmostRelativeEqual(ay1,ay2,12)
self.assertAlmostRelativeEqual(az1,az2,12)
def test15(self):
particles = plummer.new_plummer_model(512)
expected_positions = None
for mode in ["cpu", "openmp", "opencl"]:
try:
instance = Huayno(mode=mode,
number_of_workers=1) #, debugger="xterm")
except:
print("Running huayno with mode=", mode, " was unsuccessful.")
continue
else:
print("Running huayno with mode=", mode, "... ")
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length**2
instance.particles.add_particles(particles)
instance.evolve_model(0.2 | nbody_system.time)
instance.synchronize_model()
if expected_positions is None:
expected_positions = instance.particles.position
else:
self.assertAlmostRelativeEquals(expected_positions,
instance.particles.position, 8)
instance.stop()
def test16(self):
solsys = new_solar_system()
solsys.x-=1.| units.AU
p=datamodel.Particles(3)
p.mass=[1,2,3] | units.MSun
p.x=[1,10,100] | units.AU
p.y=[0,0,-10] | units.AU
p.z=[0,0,10] | units.AU
from amuse.community.huayno.interface import Huayno
from amuse.units import nbody_system
conv=nbody_system.nbody_to_si(1. | units.AU, 1.| units.MSun)
h = Huayno(conv)
h.particles.add_particles(solsys)
ax1,ay1,az1=h.get_gravity_at_point(p.x*0.,p.x,p.y,p.z)
mercury = Mercury()
mercury.particles.add_particles(solsys)
ax2,ay2,az2=mercury.get_gravity_at_point(p.x*0.,p.x,p.y,p.z)
self.assertAlmostRelativeEqual(ax1,ax2,12)
self.assertAlmostRelativeEqual(ay1,ay2,12)
self.assertAlmostRelativeEqual(az1,az2,12)
def test16(self):
instance = Huayno()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.mass = [1.] | nbody_system.mass
particles.radius = [0.0] | nbody_system.length
particles.position = [[0.0,0.0,0.0],[1.0,0.0,0.0]] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration,14)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration,14)
fx = (-1.0 / (x0**2)+1.0 / (((1.0|nbody_system.length)-x0)**2)) * (1.0 | nbody_system.length ** 3 / nbody_system.time ** 2)
self.assertAlmostEqual(fx, fx0,14)
self.assertAlmostEqual(potential0, -nbody_system.G*(1.|nbody_system.mass)*(1./x0+1./((1.|nbody_system.length)-x0)),14)
instance.stop()
def test22(self):
print(
"Testing zero-mass test particles in Huayno, can be used for removing particles when inside recursive evolve loop"
)
sun_and_earth = self.new_system_of_sun_and_earth()
period = (4.0 * math.pi**2 * (1.0 | units.AU)**3 /
(constants.G * sun_and_earth.total_mass())).sqrt()
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun,
1.0 | units.AU)
huayno = Huayno(convert_nbody)
huayno.parameters.epsilon_squared = 0.0 | units.AU**2
huayno.parameters.inttype_parameter = huayno.inttypes.SHARED8
test_particle = datamodel.Particle(mass=0 | units.MSun,
position=[4, 0, 0] | units.AU,
velocity=[0, 0, 0] | units.kms)
test_particle.vy = (constants.G * sun_and_earth.total_mass() /
(4.0 | units.AU)).sqrt()
sun_and_earth.add_particle(test_particle)
huayno.particles.add_particles(sun_and_earth)
huayno.evolve_model(period)
self.assertAlmostRelativeEqual(huayno.particles[:2].x,
sun_and_earth[:2].x, 13)
huayno.evolve_model(1.25 * period)
self.assertAlmostRelativeEqual(huayno.particles[1].y,
sun_and_earth[1].x, 13)
huayno.evolve_model(8.0 * period)
self.assertAlmostRelativeEqual(huayno.particles.x, sun_and_earth.x, 8)
huayno.stop()
def initialize_huayno(bodies, converter, huayno_eta): stars_gravity = Huayno(converter,channel_type="sockets") stars_gravity.particles.add_particles(bodies) # either bodies or just stars stars_gravity.commit_particles() #stars_gravity.set_timestep_parameter(huayno_eta) stars_gravity.parameters.timestep_parameter = huayno_eta stars_gravity.set_inttype_parameter(12) # CC_KEPLER return stars_gravity
def test5(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = Huayno(convert_nbody)
instance.initialize_code()
particles = datamodel.Particles(2)
self.assertEquals(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEquals(len(instance.particles), 2)
instance.set_state(1, 16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m,
1.0|units.ms, 1.0|units.ms, 1.0|units.ms)
curr_state = instance.get_state(1)
for expected, actural in zip((16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m,
1.0|units.ms, 1.0|units.ms, 1.0|units.ms, 0 | units.m), curr_state):
self.assertAlmostRelativeEquals(actural,expected)
instance.set_state(1, 16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m,
1.0|units.ms, 1.0|units.ms, 1.0|units.ms , 20.0|units.m)
curr_state = instance.get_state(1)
for expected, actural in zip((16|units.kg, 20.0|units.m, 40.0|units.m, 60.0|units.m,
1.0|units.ms, 1.0|units.ms, 1.0|units.ms, 20 | units.m), curr_state):
self.assertAlmostRelativeEquals(actural,expected)
def sub_worker(parts):
mode = system_type(parts)
if mode == "twobody":
code = TwoBody(conv_sub)
elif mode == "solarsystem":
#code=Mercury(conv_sub)
code = Huayno(conv_sub)
elif mode == "nbody":
code = Huayno(conv_sub)
code.parameters.inttype_parameter = code.inttypes.SHARED4
return code
def test13(self):
particles = plummer.new_plummer_model(31)
instance = Huayno(number_of_workers=1) #, debugger="xterm")
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length**2
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
expected_positions = instance.particles.position
instance.stop()
def binary_with_planet_run(m1=1.|units.MSun, m2=1.| units.MSun, m_planet=1|units.MJupiter,
r1=None, r2=None, r_planet=None, ecc_binary=0, P_binary=20 | units.day,
ecc_planet=0., P_planet=1.| units.yr, pangle_planet=0., a_planet=None,
tend=100. | units.yr,hostname=''):
dEcrit=1.e-6
three=binary_with_planet(m1=m1,m2=m2,m_planet=m_planet,r1=r1,r2=r2,r_planet=r_planet,
ecc_binary=ecc_binary,P_binary=P_binary,
ecc_planet=ecc_planet,a_planet=a_planet,pangle_planet=pangle_planet)
convert=nbody_system.nbody_to_si(1|units.MSun,1|units.AU)
code=Huayno(convert,hostname=hostname)
code.parameters.inttype_parameter=code.inttypes.SHARED10
code.parameters.timestep_parameter=.2
code.parameters.timestep=100. | units.day
dt=10000. | units.day
code.particles.add_particles(three)
E0=code.potential_energy+code.kinetic_energy
a0,eps0,pangle0=elements( three.total_mass(),
code.particles.x[2],
code.particles.y[2],
code.particles.z[2],
code.particles.vx[2],
code.particles.vy[2],
code.particles.vz[2] )
t=0. | units.day
result="stable"
while(t < tend-dt/2):
t=t+dt
code.evolve_model(t)
E=code.potential_energy+code.kinetic_energy
dE=abs(((E-E0)/E0))
a,eps,pangle=elements( three.total_mass(),
code.particles.x[2],
code.particles.y[2],
code.particles.z[2],
code.particles.vx[2],
code.particles.vy[2],
code.particles.vz[2] )
if dE > dEcrit or a<0.5*a0 or a>2.*a0:
result="unstable"
if dE > dEcrit:
result="failed"
break
code.stop()
return result,t,dE,a.in_(units.AU),eps,pangle
def test14(self):
import hashlib
numpy.random.seed(123456)
particles = plummer.new_plummer_model(64)
sha=hashlib.sha1()
class inttypes(object):
SHARED2=1
EXTRAPOLATE=5
PASS_KDK=2
PASS_DKD=7
HOLD_KDK=3
HOLD_DKD=8
PPASS_DKD=9
BRIDGE_KDK=4
BRIDGE_DKD=10
CC=11
CC_KEPLER=12
OK=13
KEPLER=14
SHARED4=15
SHARED6=18
SHARED8=19
SHARED10=20
SHAREDBS=21
@classmethod
def _list(cls):
return set([x for x in cls.__dict__.keys() if not x.startswith('_')])
for itype in sorted(inttypes._list()):
if itype in ("KEPLER"): continue
instance = Huayno()
instance.parameters.inttype_parameter=getattr(Huayno.inttypes,itype)
instance.particles.add_particles(particles)
instance.evolve_model(0.125 | nbody_system.time)
part_out= instance.particles.copy()
position = part_out.position.number
if hasattr(position,'tobytes'):
as_bytes = position.tobytes()
else:
as_bytes = numpy.copy(position.data, order='C')
sha.update(as_bytes)
instance.stop()
# this result is probably dependent on system architecture hence no good for assert
print
print sha.hexdigest()
print "8e71f9441578a43af4af927943577ad2c4130e4c"
def test13(self):
particles = plummer.new_plummer_model(31)
instance = Huayno(number_of_workers=1)#, debugger="xterm")
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length ** 2
instance.particles.add_particles(particles)
instance.evolve_model(0.1 | nbody_system.time)
instance.synchronize_model()
expected_positions = instance.particles.position
instance.stop()
def _compare_integrator_with_collision_integrator(self, inttype_parameter1, inttype_parameter2):
numpy.random.seed(12345)
particles = plummer.new_plummer_model(101)
instance = Huayno()
instance.parameters.inttype_parameter = inttype_parameter1
instance.particles.add_particles(particles)
instance.evolve_model(0.2 | nbody_system.time)
expected_position = instance.particles.position
expected_velocity = instance.particles.velocity
instance.reset()
instance.parameters.inttype_parameter = inttype_parameter2
instance.particles.add_particles(particles)
instance.evolve_model(0.2 | nbody_system.time)
self.assertAlmostRelativeEquals(expected_position, instance.particles.position, 8)
self.assertAlmostRelativeEquals(expected_velocity, instance.particles.velocity, 8)
instance.stop()
def test24(self):
print("test massless particles/ kepler integrator")
N = 20
tend = 2. | units.yr
numpy.random.seed(12345)
conv = nbody_system.nbody_to_si(4. | units.MSun, 5. | units.AU)
orbiters = plummer.new_plummer_model(N, conv)
sun = datamodel.Particle(mass=1. | units.MSun)
sun.position = [12.3, 1., -.2] | units.AU
sun.velocity = [10, 50., -20.] | units.kms
orbiters.mass *= 0.
a0, eps0 = elements(sun.mass, orbiters.x, orbiters.y, orbiters.z,
orbiters.vx, orbiters.vy, orbiters.vz)
orbiters.position += sun.position
orbiters.velocity += sun.velocity
pos = dict()
for inttype in [20, 14]:
code = Huayno(conv)
code.parameters.inttype_parameter = inttype
code.parameters.timestep_parameter = 0.1
code.particles.add_particle(sun)
orbiters2 = code.particles.add_particles(orbiters).copy()
orbiters2.position -= sun.position
orbiters2.velocity -= sun.velocity
code.evolve_model(tend)
a, eps = elements(sun.mass, orbiters2.x, orbiters2.y, orbiters2.z,
orbiters2.vx, orbiters2.vy, orbiters2.vz)
da = abs((a - a0) / a0)
deps = abs(eps - eps0) / eps0
dev = numpy.where(da > 1.e-12)[0]
self.assertEqual(len(dev), 0)
dev = numpy.where(deps > 1.e-12)[0]
self.assertEqual(len(dev), 0)
pos[inttype] = [
orbiters2.x.value_in(units.AU),
orbiters2.y.value_in(units.AU),
orbiters2.z.value_in(units.AU)
]
self.assertAlmostEqual(pos[20][0], pos[14][0], 12)
self.assertAlmostEqual(pos[20][1], pos[14][1], 12)
self.assertAlmostEqual(pos[20][2], pos[14][2], 12)
def _run_collision_with_integrator(self, inttype_parameter):
particles = datamodel.Particles(7)
particles.mass = 0.001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0
] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]
] * 3 + [[-4, 0, 0]] | nbody_system.speed
instance = Huayno()
instance.parameters.inttype_parameter = inttype_parameter
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 3)
self.assertEqual(len(collisions.particles(1)), 3)
self.assertEqual(
len(particles - collisions.particles(0) - collisions.particles(1)),
1)
self.assertEqual(
abs(collisions.particles(0).x - collisions.particles(1).x) <=
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = datamodel.Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(
0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0),
collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
instance.particles.remove_particles(
collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEqual(len(collisions.particles(0)), 1)
self.assertEqual(len(collisions.particles(1)), 1)
self.assertEqual(
len(instance.particles - collisions.particles(0) -
collisions.particles(1)), 2)
self.assertEqual(
abs(collisions.particles(0).x - collisions.particles(1).x) <=
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test28(self):
particles = plummer.new_plummer_model(31)
instance = Huayno()
instance.particles.add_particles(particles)
self.assertAlmostEqual(particles.total_mass(),instance.total_mass)
self.assertAlmostEqual(particles.center_of_mass(),instance.center_of_mass_position)
self.assertAlmostEqual(particles.center_of_mass_velocity(),instance.center_of_mass_velocity)
def test23(self):
print("testing removing and adding particles repeatedly")
N = 1100
p1 = plummer.new_plummer_model(N)
p2 = plummer.new_plummer_model(N)
h1 = Huayno()
h1.particles.add_particles(p1[:N // 2])
h1.particles.add_particles(p2[-N // 2:])
h2 = Huayno()
h2.particles.add_particles(p1)
h2.particles.remove_particles(p1[N // 2:])
h2.particles.add_particles(p2)
h2.particles.remove_particles(p2[:-N // 2])
self.assertEqual(len(h1.particles), len(h2.particles))
self.assertAlmostEqual(h1.kinetic_energy, h2.kinetic_energy, 15)
self.assertAlmostEqual(h1.potential_energy, h2.potential_energy, 15)
def test29(self):
instance = Huayno()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.position = ([0,0,0], [1,0,0] )| nbody_system.length
particles.velocity = ([-1,0,0], [2,0,0] )| nbody_system.speed
particles.radius = 0| nbody_system.length
particles.mass = 0.1| nbody_system.mass
instance.particles.add_particles(particles)
instance.stopping_conditions.out_of_box_detection.enable()
instance.parameters.stopping_conditions_out_of_box_size = 2 | nbody_system.length
instance.parameters.stopping_conditions_out_of_box_use_center_of_mass = False
instance.evolve_model(1 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.out_of_box_detection.is_set())
self.assertEquals(len(instance.stopping_conditions.out_of_box_detection.particles(0)), 1)
self.assertEquals(instance.stopping_conditions.out_of_box_detection.particles(0)[0].key, particles[1].key)
instance.stop()
def _compare_integrator_with_collision_integrator(self, inttype_parameter1, inttype_parameter2):
numpy.random.seed(12345)
particles = plummer.new_plummer_model(101)
instance = Huayno()
instance.parameters.inttype_parameter = inttype_parameter1
instance.particles.add_particles(particles)
instance.evolve_model(0.2 | nbody_system.time)
expected_position = instance.particles.position
expected_velocity = instance.particles.velocity
instance.reset()
instance.parameters.inttype_parameter = inttype_parameter2
instance.particles.add_particles(particles)
instance.evolve_model(0.2 | nbody_system.time)
self.assertAlmostRelativeEquals(expected_position, instance.particles.position, 8)
self.assertAlmostRelativeEquals(expected_velocity, instance.particles.velocity, 8)
instance.stop()
def test7(self):
print("Test7: Testing effect of Huayno parameter epsilon_squared")
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun,
1.0 | units.AU)
particles = datamodel.Particles(2)
sun = particles[0]
sun.mass = 1.0 | units.MSun
sun.position = [0.0, 0.0, 0.0] | units.AU
sun.velocity = [0.0, 0.0, 0.0] | units.AU / units.yr
sun.radius = 1.0 | units.RSun
earth = particles[1]
earth.mass = 5.9736e24 | units.kg
earth.radius = 6371.0 | units.km
earth.position = [0.0, 1.0, 0.0] | units.AU
earth.velocity = [2.0 * numpy.pi, -0.0001, 0.0] | units.AU / units.yr
initial_direction = math.atan((earth.velocity[0] / earth.velocity[1]))
final_direction = []
for log_eps2 in range(-9, 10, 2):
instance = Huayno(convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU**2
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.25 | units.yr)
final_direction.append(
math.atan((instance.particles[1].velocity[0] /
instance.particles[1].velocity[1])))
instance.stop()
# Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees
self.assertAlmostEqual(abs(final_direction[0]),
abs(initial_direction + math.pi / 2.0), 2)
# Large values of epsilon_squared should result in ~ no interaction
self.assertAlmostEqual(final_direction[-1], initial_direction, 2)
# Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2
delta = [
abs(final_direction[i + 1] - final_direction[i])
for i in range(len(final_direction) - 1)
]
self.assertEqual(delta[len(final_direction) // 2 - 1], max(delta))
def test24(self):
print "test massless particles/ kepler integrator"
N=20
tend=2.| units.yr
numpy.random.seed(12345)
conv=nbody_system.nbody_to_si(4.| units.MSun, 5.|units.AU)
orbiters=plummer.new_plummer_model(N,conv)
sun=datamodel.Particle(mass=1.|units.MSun)
sun.position=[12.3,1.,-.2]|units.AU
sun.velocity=[10,50.,-20.]|units.kms
orbiters.mass*=0.
a0,eps0=elements(sun.mass,orbiters.x,orbiters.y,orbiters.z,
orbiters.vx,orbiters.vy,orbiters.vz)
orbiters.position+=sun.position
orbiters.velocity+=sun.velocity
pos=dict()
for inttype in [20,14]:
code=Huayno(conv)
code.parameters.inttype_parameter=inttype
code.parameters.timestep_parameter=0.1
code.particles.add_particle(sun)
orbiters2=code.particles.add_particles(orbiters).copy()
orbiters2.position-=sun.position
orbiters2.velocity-=sun.velocity
code.evolve_model(tend)
a,eps=elements(sun.mass,orbiters2.x,orbiters2.y,orbiters2.z,
orbiters2.vx,orbiters2.vy,orbiters2.vz)
da=abs((a-a0)/a0)
deps=abs(eps-eps0)/eps0
dev=numpy.where(da > 1.e-12)[0]
self.assertEqual( len(dev),0)
dev=numpy.where(deps > 1.e-12)[0]
self.assertEqual( len(dev),0)
pos[inttype]=[orbiters2.x.value_in(units.AU),orbiters2.y.value_in(units.AU),orbiters2.z.value_in(units.AU)]
self.assertAlmostEqual(pos[20][0],pos[14][0],12)
self.assertAlmostEqual(pos[20][1],pos[14][1],12)
self.assertAlmostEqual(pos[20][2],pos[14][2],12)
def test25(self):
print("test massless particles/ kepler integrator, smoothed")
N = 10
tend = 20. | units.yr
numpy.random.seed(12345)
conv = nbody_system.nbody_to_si(4. | units.MSun, 5. | units.AU)
orbiters = plummer.new_plummer_model(N, conv)
sun = datamodel.Particle(mass=1. | units.MSun)
sun.position = [0, 0, 0] | units.AU
sun.velocity = [0, 0, 0] | units.kms
orbiters.mass *= 0.
eps = (5. | units.AU)
e0 = energy(sun.mass, eps, orbiters)
l0 = angular_momentum(orbiters)
pos = dict()
for inttype in [20, 14]:
code = Huayno(conv)
code.parameters.inttype_parameter = inttype
code.parameters.timestep_parameter = 0.1
code.parameters.epsilon_squared = eps**2
code.particles.add_particle(sun)
orbiters2 = code.particles.add_particles(orbiters)
code.evolve_model(tend)
e1 = energy(sun.mass, eps, orbiters2)
l1 = angular_momentum(orbiters2)
de, dl = abs((e1 - e0) / e0).max(), abs((l1 - l0) / l1).max()
self.assertTrue(numpy.all(de < 1.e-8))
self.assertTrue(numpy.all(dl < 1.e-8))
pos[inttype] = [
orbiters2.x.value_in(units.AU),
orbiters2.y.value_in(units.AU),
orbiters2.z.value_in(units.AU)
]
self.assertAlmostRelativeEqual(pos[20][0], pos[14][0],
4) # still not clear why 4
self.assertAlmostRelativeEqual(pos[20][1], pos[14][1], 4)
self.assertAlmostRelativeEqual(pos[20][2], pos[14][2], 4)
def test6(self):
print "Test6: Testing Huayno parameters"
convert_nbody = nbody_system.nbody_to_si(1.0 | units.yr, 1.0 | units.AU)
instance = Huayno(convert_nbody)
(value, error) = instance.legacy_interface.get_eps2()
self.assertEquals(0, error)
self.assertEquals(0.0, value)
self.assertAlmostEquals(0.0 | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2)
for x in [0.01, 0.1, 0.2]:
instance.parameters.epsilon_squared = x | units.AU**2
self.assertAlmostEquals(x | units.AU**2, instance.parameters.epsilon_squared, in_units=units.AU**2)
(value, error) = instance.legacy_interface.get_time()
self.assertEquals(0, error)
self.assertEquals(0.0, value)
self.assertAlmostEquals(0.0 | units.yr, instance.parameters.begin_time, in_units=units.yr)
for x in [1.0, 10.0, 100.0]:
instance.parameters.begin_time = x | units.yr
self.assertAlmostEquals(x | units.yr, instance.parameters.begin_time, in_units=units.yr)
instance.stop()
def test16(self):
instance = Huayno()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.mass = [1.] | nbody_system.mass
particles.radius = [0.0] | nbody_system.length
particles.position = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]
] | nbody_system.length
particles.velocity = [[0.0, 0.0, 0.0]] | nbody_system.speed
instance.particles.add_particles(particles)
zero = 0.0 | nbody_system.length
for x in (0.25, 0.5, 0.75):
x0 = x | nbody_system.length
potential0 = instance.get_potential_at_point(zero, x0, zero, zero)
fx0, fy0, fz0 = instance.get_gravity_at_point(zero, x0, zero, zero)
self.assertAlmostEqual(fy0, 0.0 | nbody_system.acceleration, 14)
self.assertAlmostEqual(fz0, 0.0 | nbody_system.acceleration, 14)
fx = (-1.0 / (x0**2) + 1.0 /
(((1.0 | nbody_system.length) - x0)**2)) * (
1.0 | nbody_system.length**3 / nbody_system.time**2)
self.assertAlmostEqual(fx, fx0, 14)
self.assertAlmostEqual(
potential0, -nbody_system.G * (1. | nbody_system.mass) *
(1. / x0 + 1. / ((1. | nbody_system.length) - x0)), 14)
instance.stop()
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 timefractal(N=1000,
fd=1.6,
tend=0.25 | nbody_system.time,
inttype=Huayno.inttypes.HOLD_DKD,
seed=12345678):
stars = new_fractal_cluster_model(N=N,
fractal_dimension=fd,
random_seed=seed,
virial_ratio=0.5,
do_scale=True,
verbose=False)
code = Huayno()
code.parameters.inttype_parameter = inttype
code.parameters.timestep_parameter = 0.01
code.particles.add_particles(stars)
E0 = code.kinetic_energy + code.potential_energy
p0 = code.particles.total_momentum()
t1 = time()
code.evolve_model(tend)
t2 = time()
E = code.kinetic_energy + code.potential_energy
p = code.particles.total_momentum()
code.stop()
return t2 - t1, abs(E0 - E) / E0, p0 - p
def test27(self):
particles = plummer.new_plummer_model(31)
tend=0.25| nbody_system.time
instance = Huayno()
instance.particles.add_particles(particles)
instance.evolve_model(tend)
expected_positions = instance.particles.position
self.assertEqual(instance.model_time, tend)
instance.stop()
particles2=particles.copy()
particles2.velocity*=-1
instance = Huayno()
instance.particles.add_particles(particles2)
instance.evolve_model(-tend)
positions = instance.particles.position
self.assertEqual(instance.model_time, -tend)
instance.stop()
self.assertAlmostEqual(positions,expected_positions)
def test4(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg, 10.0 | units.m)
instance = Huayno(convert_nbody)
instance.initialize_code()
particles = datamodel.Particles(2)
self.assertEquals(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEquals(len(instance.particles), 2)
instance.particles.mass = [17.0, 33.0] | units.kg
self.assertEquals(instance.get_mass(0), 17.0| units.kg)
self.assertEquals(instance.get_mass(1), 33.0| units.kg)
def test4(self):
convert_nbody = nbody_system.nbody_to_si(5.0 | units.kg,
10.0 | units.m)
instance = Huayno(convert_nbody)
instance.initialize_code()
particles = datamodel.Particles(2)
self.assertEqual(len(instance.particles), 0)
particles.mass = [15.0, 30.0] | units.kg
particles.radius = [10.0, 20.0] | units.m
particles.position = [[10.0, 20.0, 30.0], [20.0, 40.0, 60.0]] | units.m
particles.velocity = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]
] | units.m / units.s
instance.particles.add_particles(particles)
self.assertEqual(len(instance.particles), 2)
instance.particles.mass = [17.0, 33.0] | units.kg
self.assertEqual(instance.get_mass(0), 17.0 | units.kg)
self.assertEqual(instance.get_mass(1), 33.0 | units.kg)
def orbit_evolve(bodies, time_peri, eta, n_steps=100):
converter = nbody_system.nbody_to_si(1 | units.MSun, 1 | units.AU)
gravity = Huayno(converter, channel_type="sockets")
gravity.particles.add_particles(bodies)
gravity.commit_particles()
gravity.parameters.timestep_parameter = eta
channel_from_gravity_to_framework = gravity.particles.new_channel_to(
bodies)
Etot_init = gravity.kinetic_energy + gravity.potential_energy
Etot = Etot_init
file_snap = "orbit_ini.hdf5"
t_end = 2.0 * abs(time_peri.value_in(units.yr)) | units.yr
dt = t_end / float(n_steps)
time = 0.0 | units.yr
while time <= t_end:
gravity.evolve_model(time)
channel_from_gravity_to_framework.copy()
bodies.age = time
# checking energy conservation
Ekin = gravity.kinetic_energy
Epot = gravity.potential_energy
Etot = Ekin + Epot
dE = Etot_init - Etot
# output centerd on the bodies[0] star
bodies.position -= bodies[0].position
bodies.velocity -= bodies[0].velocity
write_set_to_file(bodies, file_snap, "hdf5")
rel_r = (bodies[1].position - bodies[0].position).lengths()
print " \t\t", time, "\t", dE / Etot_init, rel_r.in_(units.AU)
time += dt
gravity.stop()
bodies.position -= bodies[0].position
bodies.velocity -= bodies[0].velocity
print bodies
return
def initialize_huayno(bodies, converter, huayno_eta): stars_gravity = Huayno(converter,channel_type="sockets") stars_gravity.particles.add_particles(bodies) # either bodies or just stars stars_gravity.commit_particles() #stars_gravity.set_timestep_parameter(huayno_eta) stars_gravity.parameters.timestep_parameter = huayno_eta stars_gravity.set_inttype_parameter(12) # CC_KEPLER return stars_gravity
def test22(self):
print "Testing zero-mass test particles in Huayno, can be used for removing particles when inside recursive evolve loop"
sun_and_earth = self.new_system_of_sun_and_earth()
period = (4.0 * math.pi**2 * (1.0 | units.AU)**3 / (constants.G * sun_and_earth.total_mass())).sqrt()
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
huayno = Huayno(convert_nbody)
huayno.parameters.epsilon_squared = 0.0 | units.AU**2
huayno.parameters.inttype_parameter = huayno.inttypes.SHARED8
test_particle = datamodel.Particle(mass=0|units.MSun, position=[4,0,0]|units.AU, velocity=[0,0,0]|units.kms)
test_particle.vy = (constants.G * sun_and_earth.total_mass() / (4.0 | units.AU)).sqrt()
sun_and_earth.add_particle(test_particle)
huayno.particles.add_particles(sun_and_earth)
huayno.evolve_model(period)
self.assertAlmostRelativeEqual(huayno.particles[:2].x, sun_and_earth[:2].x, 13)
huayno.evolve_model(1.25 * period)
self.assertAlmostRelativeEqual(huayno.particles[1].y, sun_and_earth[1].x, 13)
huayno.evolve_model(8.0 * period)
self.assertAlmostRelativeEqual(huayno.particles.x, sun_and_earth.x, 8)
huayno.stop()
def test25(self):
print "test massless particles/ kepler integrator, smoothed"
N=10
tend=20.| units.yr
numpy.random.seed(12345)
conv=nbody_system.nbody_to_si(4.| units.MSun, 5.|units.AU)
orbiters=plummer.new_plummer_model(N,conv)
sun=datamodel.Particle(mass=1.|units.MSun)
sun.position=[0,0,0]|units.AU
sun.velocity=[0,0,0]|units.kms
orbiters.mass*=0.
eps=(5. | units.AU)
e0=energy(sun.mass,eps,orbiters)
l0=angular_momentum(orbiters)
pos=dict()
for inttype in [20,14]:
code=Huayno(conv)
code.parameters.inttype_parameter=inttype
code.parameters.timestep_parameter=0.1
code.parameters.epsilon_squared=eps**2
code.particles.add_particle(sun)
orbiters2=code.particles.add_particles(orbiters)
code.evolve_model(tend)
e1=energy(sun.mass,eps,orbiters2)
l1=angular_momentum(orbiters2)
de,dl=abs((e1-e0)/e0).max(),abs((l1-l0)/l1).max()
self.assertTrue( numpy.all(de< 1.e-8))
self.assertTrue( numpy.all(dl< 1.e-8))
pos[inttype]=[orbiters2.x.value_in(units.AU),orbiters2.y.value_in(units.AU),orbiters2.z.value_in(units.AU)]
self.assertAlmostRelativeEqual(pos[20][0],pos[14][0],4) # still not clear why 4
self.assertAlmostRelativeEqual(pos[20][1],pos[14][1],4)
self.assertAlmostRelativeEqual(pos[20][2],pos[14][2],4)
def _run_collision_with_integrator(self, inttype_parameter):
particles = datamodel.Particles(7)
particles.mass = 0.001 | nbody_system.mass
particles.radius = 0.01 | nbody_system.length
particles.x = [-101.0, -100.0, -0.5, 0.5, 100.0, 101.0, 104.0] | nbody_system.length
particles.y = 0 | nbody_system.length
particles.z = 0 | nbody_system.length
particles.velocity = [[2, 0, 0], [-2, 0, 0]]*3 + [[-4, 0, 0]] | nbody_system.speed
instance = Huayno()
instance.parameters.inttype_parameter = inttype_parameter
instance.particles.add_particles(particles)
collisions = instance.stopping_conditions.collision_detection
collisions.enable()
instance.evolve_model(1.0 | nbody_system.time)
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 0.5 | nbody_system.time)
self.assertEquals(len(collisions.particles(0)), 3)
self.assertEquals(len(collisions.particles(1)), 3)
self.assertEquals(len(particles - collisions.particles(0) - collisions.particles(1)), 1)
self.assertEquals(abs(collisions.particles(0).x - collisions.particles(1).x) <=
(collisions.particles(0).radius + collisions.particles(1).radius),
[True, True, True])
sticky_merged = datamodel.Particles(len(collisions.particles(0)))
sticky_merged.mass = collisions.particles(0).mass + collisions.particles(1).mass
sticky_merged.radius = collisions.particles(0).radius
for p1, p2, merged in zip(collisions.particles(0), collisions.particles(1), sticky_merged):
merged.position = (p1 + p2).center_of_mass()
merged.velocity = (p1 + p2).center_of_mass_velocity()
print instance.model_time
print instance.particles
instance.particles.remove_particles(collisions.particles(0) + collisions.particles(1))
instance.particles.add_particles(sticky_merged)
instance.evolve_model(1.0 | nbody_system.time)
print
print instance.model_time
print instance.particles
self.assertTrue(collisions.is_set())
self.assertTrue(instance.model_time < 1.0 | nbody_system.time)
self.assertEquals(len(collisions.particles(0)), 1)
self.assertEquals(len(collisions.particles(1)), 1)
self.assertEquals(len(instance.particles - collisions.particles(0) - collisions.particles(1)), 2)
self.assertEquals(abs(collisions.particles(0).x - collisions.particles(1).x) <=
(collisions.particles(0).radius + collisions.particles(1).radius),
[True])
instance.stop()
def test14(self):
import hashlib
numpy.random.seed(123456)
particles = plummer.new_plummer_model(64)
sha = hashlib.sha1()
class inttypes(object):
SHARED2 = 1
EXTRAPOLATE = 5
PASS_KDK = 2
PASS_DKD = 7
HOLD_KDK = 3
HOLD_DKD = 8
PPASS_DKD = 9
BRIDGE_KDK = 4
BRIDGE_DKD = 10
CC = 11
CC_KEPLER = 12
OK = 13
KEPLER = 14
SHARED4 = 15
SHARED6 = 18
SHARED8 = 19
SHARED10 = 20
SHAREDBS = 21
@classmethod
def _list(cls):
return set(
[x for x in cls.__dict__.keys() if not x.startswith('_')])
for itype in sorted(inttypes._list()):
if itype in ("KEPLER"): continue
instance = Huayno()
instance.parameters.inttype_parameter = getattr(
Huayno.inttypes, itype)
instance.particles.add_particles(particles)
instance.evolve_model(0.125 | nbody_system.time)
part_out = instance.particles.copy()
position = part_out.position.number
if hasattr(position, 'tobytes'):
as_bytes = position.tobytes()
else:
as_bytes = numpy.array(position.data, copy=True, order='C')
sha.update(as_bytes)
instance.stop()
# this result is probably dependent on system architecture hence no good for assert
print
print sha.hexdigest()
print "8e71f9441578a43af4af927943577ad2c4130e4c"
def test15(self):
particles = plummer.new_plummer_model(512)
expected_positions = None
for mode in ["cpu", "openmp", "opencl"]:
try:
instance = Huayno(mode=mode, number_of_workers=1)#, debugger="xterm")
except:
print "Running huayno with mode=", mode, " was unsuccessful."
continue
else:
print "Running huayno with mode=", mode, "... "
instance.initialize_code()
instance.parameters.epsilon_squared = 0.01 | nbody_system.length ** 2
instance.particles.add_particles(particles)
instance.evolve_model(0.2 | nbody_system.time)
instance.synchronize_model()
if expected_positions is None:
expected_positions = instance.particles.position
else:
self.assertAlmostRelativeEquals(expected_positions, instance.particles.position, 8)
instance.stop()
def test7(self):
print "Test7: Testing effect of Huayno parameter epsilon_squared"
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
particles = datamodel.Particles(2)
sun = particles[0]
sun.mass = 1.0 | units.MSun
sun.position = [0.0, 0.0, 0.0] | units.AU
sun.velocity = [0.0, 0.0, 0.0] | units.AU / units.yr
sun.radius = 1.0 | units.RSun
earth = particles[1]
earth.mass = 5.9736e24 | units.kg
earth.radius = 6371.0 | units.km
earth.position = [0.0, 1.0, 0.0] | units.AU
earth.velocity = [2.0*numpy.pi, -0.0001, 0.0] | units.AU / units.yr
initial_direction = math.atan((earth.velocity[0]/earth.velocity[1]))
final_direction = []
for log_eps2 in range(-9,10,2):
instance = Huayno(convert_nbody)
instance.initialize_code()
instance.parameters.epsilon_squared = 10.0**log_eps2 | units.AU ** 2
instance.particles.add_particles(particles)
instance.commit_particles()
instance.evolve_model(0.25 | units.yr)
final_direction.append(math.atan((instance.particles[1].velocity[0]/
instance.particles[1].velocity[1])))
instance.stop()
# Small values of epsilon_squared should result in normal earth-sun dynamics: rotation of 90 degrees
self.assertAlmostEquals(abs(final_direction[0]), abs(initial_direction+math.pi/2.0), 2)
# Large values of epsilon_squared should result in ~ no interaction
self.assertAlmostEquals(final_direction[-1], initial_direction, 2)
# Outcome is most sensitive to epsilon_squared when epsilon_squared = d(earth, sun)^2
delta = [abs(final_direction[i+1]-final_direction[i]) for i in range(len(final_direction)-1)]
self.assertEquals(delta[len(final_direction)/2 -1], max(delta))
def orbit_evolve(bodies, time_peri, eta, n_steps=100):
converter=nbody_system.nbody_to_si(1|units.MSun,1|units.AU)
gravity = Huayno(converter,channel_type="sockets")
gravity.particles.add_particles(bodies)
gravity.commit_particles()
gravity.parameters.timestep_parameter = eta
channel_from_gravity_to_framework = gravity.particles.new_channel_to(bodies)
Etot_init = gravity.kinetic_energy + gravity.potential_energy
Etot = Etot_init
file_snap = "orbit_ini.hdf5"
t_end = 2.0*abs(time_peri.value_in(units.yr)) | units.yr
dt = t_end / float(n_steps)
time = 0.0 | units.yr
while time <= t_end:
gravity.evolve_model(time)
channel_from_gravity_to_framework.copy()
bodies.age = time
# checking energy conservation
Ekin = gravity.kinetic_energy
Epot = gravity.potential_energy
Etot = Ekin + Epot
dE = Etot_init-Etot
# output centerd on the bodies[0] star
bodies.position -= bodies[0].position
bodies.velocity -= bodies[0].velocity
write_set_to_file(bodies, file_snap, "hdf5")
rel_r = (bodies[1].position - bodies[0].position).lengths()
print " \t\t", time, "\t", dE/Etot_init, rel_r.in_(units.AU)
time += dt
gravity.stop()
bodies.position -= bodies[0].position
bodies.velocity -= bodies[0].velocity
print bodies
return
def test2(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.0 | units.AU**2
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
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()
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 = [t_x[1].value_in(units.AU) for t_x in x_points]
y_points_in_AU = [t_x1[1].value_in(units.AU) for t_x1 in 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,
"huayno-earth-sun2.svg")
figure.savefig(output_file)
instance.cleanup_code()
del instance
def test14c(self):
import hashlib
numpy.random.seed(123456)
particles = plummer.new_plummer_model(16)
particles.mass *= 0.25
p2 = plummer.new_plummer_model(16)
p2.mass *= 0.75
sha = hashlib.sha1()
test_set = [
"CONSTANT", "SHARED2", "EXTRAPOLATE", "PASS_KDK", "PASS_DKD",
"HOLD_KDK", "HOLD_DKD", "PPASS_DKD", "BRIDGE_KDK", "BRIDGE_DKD",
"CC", "CC_KEPLER", "CC_BS", "CC_BSA", "OK", "SHAREDBS", "SHARED4",
"SHARED6", "SHARED8", "SHARED10"
]
#~ test_set=["CC_BS"]
for itype in test_set:
#~ print()
#~ print(itype)
instance = Huayno(redirection="none")
instance.parameters.inttype_parameter = Huayno.all_inttypes[itype]
instance.parameters.accelerate_zero_mass = True
instance.particles.add_particles(particles)
instance.particles.add_particles(p2)
E1 = instance.kinetic_energy + instance.potential_energy
instance.evolve_model(0.125 | nbody_system.time)
E2 = instance.kinetic_energy + instance.potential_energy
#~ if itype!="CONSTANT":
#~ self.assertLess(abs(E2-E1).number, 1.e-5)
#~ print((E2-E1).number)
part_out = instance.particles.copy()
position = part_out.position.number
if hasattr(position, 'tobytes'):
as_bytes = position.tobytes()
else:
as_bytes = numpy.array(position.data, copy=True, order='C')
sha.update(as_bytes)
instance.stop()
# this result is probably dependent on system architecture hence no good for assert
print()
print(sha.hexdigest())
print("0af7eaea472989ea4be1bb0e2b8633d6b9af41e4")
def timerun(N=1000,f_bin=1.,tend=0.25| nbody_system.time,inttype=Huayno.inttypes.HOLD_DKD,seed=12345678,logamin=-4): stars = plummer_w_binaries(N=N,f_bin=f_bin,seed=seed,logamin=logamin) code=Huayno() code.parameters.inttype_parameter=inttype code.parameters.timestep_parameter=0.01 code.particles.add_particles(stars) E0=code.kinetic_energy+code.potential_energy p0=code.particles.total_momentum() t1=time() code.evolve_model(tend) t2=time() E=code.kinetic_energy+code.potential_energy p=code.particles.total_momentum() code.stop() return t2-t1,abs((E0-E)/E0),p0-p
def initialize_huayno(bodies, converter, huayno_eta):
""" initialize huayno code """
gravity = Huayno(converter,channel_type="sockets")
gravity.particles.add_particles(bodies) # either bodies or just stars
gravity.commit_particles()
#gravity.set_timestep_parameter(huayno_eta)
gravity.parameters.timestep_parameter = huayno_eta
gravity.set_inttype_parameter(8) # CC_KEPLER
"""
Huayno Options:
(pass / hold / bridge / maybe shared? are described in the Huayno Paper)
SHARED2=1
EXTRAPOLATE=5
PASS_KDK=2
PASS_DKD=7
HOLD_KDK=3
HOLD_DKD=8 <<<<-------
PPASS_DKD=9
BRIDGE_KDK=4
BRIDGE_DKD=10
CC=11
CC_KEPLER=12 <<<<-------
OK=13
KEPLER=14
SHARED4=15
SHARED6=18
SHARED8=19
SHARED10=20
SHAREDBS=21 **BS**
CCC=22
CCC_KEPLER=23
CC_BS=24 **BS**
CCC_BS=25 **BS**
BS_CC_KEPLER=26 **BS**
CC_BSA=27 **BS** ???
CCC_BSA=28 **BS** ???
SHARED2_COLLISIONS=29
SHARED4_COLLISIONS=30
SHARED6_COLLISIONS=31
SHARED8_COLLISIONS=32
SHARED10_COLLISIONS=33
"""
return gravity
def test14(self):
import hashlib
numpy.random.seed(123456)
particles = plummer.new_plummer_model(32)
sha = hashlib.sha1()
test_set = [
"CONSTANT", "SHARED2", "EXTRAPOLATE", "PASS_KDK", "PASS_DKD",
"HOLD_KDK", "HOLD_DKD", "PPASS_DKD", "BRIDGE_KDK", "BRIDGE_DKD",
"CC", "CC_KEPLER", "CC_BS", "CC_BSA", "OK", "SHAREDBS", "SHARED4",
"SHARED6", "SHARED8", "SHARED10"
]
#~ test_set=["CONSTANT"]
for itype in test_set:
#~ print()
#~ print(itype)
instance = Huayno()
instance.parameters.inttype_parameter = Huayno.all_inttypes[itype]
#~ instance.parameters.accelerate_zero_mass=False
instance.particles.add_particles(particles)
E1 = instance.kinetic_energy + instance.potential_energy
instance.evolve_model(0.125 | nbody_system.time)
E2 = instance.kinetic_energy + instance.potential_energy
if itype != "CONSTANT":
self.assertLess(abs(E2 - E1).number, 1.e-5)
#~ print((E2-E1).number)
part_out = instance.particles.copy()
position = part_out.position.number
if hasattr(position, 'tobytes'):
as_bytes = position.tobytes()
else:
as_bytes = numpy.array(position.data, copy=True, order='C')
sha.update(as_bytes)
instance.stop()
# this result is probably dependent on system architecture hence no good for assert
print()
print(sha.hexdigest())
print("4f2aac4d8761f3b07545dcea53f1a65f84a5275b")
def test2(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.0 | units.AU**2
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
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()
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, "huayno-earth-sun2.svg")
figure.savefig(output_file)
instance.cleanup_code()
del instance
def test29(self):
instance = Huayno()
instance.parameters.epsilon_squared = 0.0 | nbody_system.length**2
particles = datamodel.Particles(2)
particles.position = ([0,0,0], [1,0,0] )| nbody_system.length
particles.velocity = ([-1,0,0], [2,0,0] )| nbody_system.speed
particles.radius = 0| nbody_system.length
particles.mass = 0.1| nbody_system.mass
instance.particles.add_particles(particles)
instance.stopping_conditions.out_of_box_detection.enable()
instance.parameters.stopping_conditions_out_of_box_size = 2 | nbody_system.length
instance.parameters.stopping_conditions_out_of_box_use_center_of_mass = False
instance.evolve_model(1 | nbody_system.time)
self.assertTrue(instance.stopping_conditions.out_of_box_detection.is_set())
self.assertEqual(len(instance.stopping_conditions.out_of_box_detection.particles(0)), 1)
self.assertEqual(instance.stopping_conditions.out_of_box_detection.particles(0)[0].key, particles[1].key)
instance.stop()
def test27(self):
particles = plummer.new_plummer_model(31)
tend = 0.25 | nbody_system.time
instance = Huayno()
instance.particles.add_particles(particles)
instance.evolve_model(tend)
expected_positions = instance.particles.position
self.assertEqual(instance.model_time, tend)
instance.stop()
particles2 = particles.copy()
particles2.velocity *= -1
instance = Huayno()
instance.particles.add_particles(particles2)
instance.evolve_model(-tend)
positions = instance.particles.position
self.assertEqual(instance.model_time, -tend)
instance.stop()
self.assertAlmostEqual(positions, expected_positions)
def test_run():
three=binary_with_planet(
m1=0.6897 | units.MSun,m2=0.20255 | units.MSun,m_planet=0.333 | units.MJupiter,
r1=0.6489 | units.RSun,r2=0.22623 | units.RSun,r_planet=0.754 | units.RJupiter,
ecc_binary=0.15944,P_binary=41.08| units.day,ecc_planet=0.00685,a_planet=.7048 | units.AU,
pangle_planet=0.)
convert=nbody_system.nbody_to_si(1|units.MSun,1|units.AU)
code=Huayno(convert)
code.parameters.inttype_parameter=code.inttypes.SHARED4
code.parameters.timestep_parameter=0.1
# tend=100. | units.yr
tend=100. | units.day
snapfreq=1
dt=10. | units.day
# dt=convert.to_si( 1. | nbody_system.time).in_(units.day)
code.particles.add_particles(three)
x = AdaptingVectorQuantity()
y = AdaptingVectorQuantity()
z = AdaptingVectorQuantity()
vx = AdaptingVectorQuantity()
vy = AdaptingVectorQuantity()
vz = AdaptingVectorQuantity()
x.append(code.particles.x)
y.append(code.particles.y)
z.append(code.particles.z)
vx.append(code.particles.vx)
vy.append(code.particles.vy)
vz.append(code.particles.vz)
ts=[0.]
E0=code.potential_energy+code.kinetic_energy
dE=[1.e-14]
t=0. | units.day
i=0
while(t < tend-dt/2):
i+=1
t=t+dt
if i%snapfreq==0:
print t
ts.append(t.value_in(units.day))
code.evolve_model(t)
x.append(code.particles.x)
y.append(code.particles.y)
z.append(code.particles.z)
vx.append(code.particles.vx)
vy.append(code.particles.vy)
vz.append(code.particles.vz)
E=code.potential_energy+code.kinetic_energy
dE.append(abs(((E-E0)/E0)))
code.stop()
a,eps,pangle=elements(three.total_mass(),
x[:,2],
y[:,2],
z[:,2],
vx[:,2],
vy[:,2],
vz[:,2])
x=x.value_in(units.AU)
y=y.value_in(units.AU)
a=a.value_in(units.AU)
eps=eps
print a[-1],eps[-1],pangle[-1]
f=pyplot.figure(figsize=(8,8))
pyplot.plot(x[:,0],y[:,0],'r.')
pyplot.plot(x[:,1],y[:,1],'g.')
pyplot.plot(x[:,2],y[:,2],'b.')
pyplot.xlim(-3,3)
pyplot.ylim(-3,3)
pyplot.xlabel('AU')
pyplot.savefig('three_16b.eps')
f=pyplot.figure(figsize=(8,8))
pyplot.semilogy(ts,dE,'g.')
pyplot.xlabel('time (day)')
pyplot.ylabel('dE/E0')
pyplot.savefig('three_16b_eerr.eps')
f=pyplot.figure(figsize=(8,8))
pyplot.plot(ts,a,'g.')
pyplot.xlabel('time (day)')
pyplot.ylabel('a (AU)')
pyplot.savefig('three_16b_a.eps')
f=pyplot.figure(figsize=(8,8))
pyplot.plot(ts,eps,'g.')
pyplot.xlabel('time (day)')
pyplot.ylabel('eccentricity')
pyplot.savefig('three_16b_ecc.eps')
f=pyplot.figure(figsize=(8,8))
pyplot.plot(ts,pangle,'g.')
pyplot.xlabel('time (day)')
pyplot.ylabel('long. of periapsis')
pyplot.savefig('three_16b_pangle.eps')
def integrate_disk_flyby(stars, planetesimals, t_end, n_steps,
snap_dir, file_out, file_redir, huayno_eta):
converter=nbody_system.nbody_to_si(1|units.MSun,1|units.AU)
planetesimals.position += stars[0].position
planetesimals.velocity += stars[0].velocity
bodies = ParticlesSuperset([stars, planetesimals])
if file_redir is None:
gravity = Huayno(converter, channel_type="sockets",
mode="openmp") # Add this (specify a number of cores)
elif file_redir=="0":
gravity = Huayno(converter, channel_type="sockets", redirection="none",
mode="openmp")
else:
gravity = Huayno(converter, channel_type="sockets", redirection="file", redirect_file=file_redir,
mode="openmp")
gravity.particles.add_particles(bodies)
gravity.commit_particles()
gravity.parameters.timestep_parameter = huayno_eta
time_step = gravity.get_timestep_parameter()
#gravity.set_inttype_parameter(12)
#gravity.set_inttype_parameter(8)
gravity.set_eps2_parameter(0.001*0.001) # Softening Parameter
print ' ** timestep: ', gravity.get_timestep_parameter()
print ' ** inttype: ', gravity.get_inttype_parameter()
print ' ** eps2: ', gravity.get_eps2_parameter(), numpy.sqrt(gravity.get_eps2_parameter())
t0 = time.time()
evolve_disk_flyby(bodies, gravity,
t_end, n_steps, converter, snap_dir, file_out)
t1= time.time()
dt = t1-t0
print "Performace data: N =", len(bodies), "dt=", dt, "s =", dt/60.0, "min"
return
def evolution_of_the_cluster(self, cluster):
'''
Function that makes de cluster evolution.
input: cluster -> defined in an inertial frame (centered at the
Galactic center)
steps in this function:
1. From cluster, another cluster is defined in a rotating frame
2. The gravity code is initialized
3. The stellar evolution is initialized
4. the Galaxy model is constructed
5. The Galaxy and the cluster in the rotating frame are coupled via the
Rotating Bridge
6. The evolution of the system is made
7. the cluster properties are transformed back to the inertial frame
'''
cluster_in_rotating_frame = self.creation_cluster_in_rotating_frame(
cluster)
# N body code
epsilon = self.softening(cluster)
convert_nbody = nbody_system.nbody_to_si(
cluster.mass.sum(), cluster.virial_radius())
gravity = Huayno(convert_nbody)
gravity.parameters.timestep = self.dt_bridge/3.
gravity.particles.add_particles(cluster_in_rotating_frame)
gravity.parameters.epsilon_squared = epsilon**2
channel_from_gravity_to_rotating_cluster = \
gravity.particles.new_channel_to(
cluster_in_rotating_frame)
channel_from_rotating_cluster_to_gravity = \
cluster_in_rotating_frame.new_channel_to(gravity.particles)
# stellar evolution code
se = SeBa()
se.particles.add_particles(cluster_in_rotating_frame)
channel_from_rotating_cluster_to_se = \
cluster_in_rotating_frame.new_channel_to(se.particles)
channel_from_se_to_rotating_cluster = se.particles.new_channel_to(
cluster_in_rotating_frame)
# Galaxy model and Rotating bridge
MW = self.galactic_model()
system = Rotating_Bridge(
self.omega_system,
timestep=self.dt_bridge,
verbose=False,
method=self.method)
system.add_system(gravity, (MW,), False)
system.add_system(MW, (), False)
X = []
Y = []
T = []
# Cluster evolution
while (self.time <= self.t_end-self.dt_bridge/2):
self.time += self.dt_bridge
system.evolve_model(self.time)
se.evolve_model(self.time)
channel_from_gravity_to_rotating_cluster.copy_attributes(
['x', 'y', 'z', 'vx', 'vy', 'vz'])
channel_from_se_to_rotating_cluster.copy_attributes(
[
'mass', 'radius', 'luminosity', 'age', 'temperature',
'stellar_type'
]
)
channel_from_rotating_cluster_to_gravity.copy_attributes(['mass'])
self.from_noinertial_to_cluster_in_inertial_frame(
cluster_in_rotating_frame, cluster)
time = self.time.value_in(units.Myr)
cm = cluster.center_of_mass()
# write data
if ((time == 2) or (time == 50) or (time == 100) or (time == 150)):
X.append((cluster.x-cm[0]).value_in(units.kpc))
Y.append((cluster.y-cm[1]).value_in(units.kpc))
T.append(time)
gravity.stop()
se.stop()
return T, X, Y
def evolve_triple_with_wind(M1, M2, M3, Pora, Pin_0, ain_0, aout_0,
ein_0, eout_0, t_end, nsteps, scheme, integrator,
t_stellar, dt_se, dtse_fac, interp):
import random
from amuse.ext.solarsystem import get_position
numpy.random.seed(42)
print("Initial masses:", M1, M2, M3)
triple = Particles(3)
triple[0].mass = M1
triple[1].mass = M2
triple[2].mass = M3
stellar = SeBa()
stellar.particles.add_particles(triple)
channel_from_stellar = stellar.particles.new_channel_to(triple)
# Evolve to t_stellar.
stellar.evolve_model(t_stellar)
channel_from_stellar.copy_attributes(["mass"])
M1 = triple[0].mass
M2 = triple[1].mass
M3 = triple[2].mass
print("t=", stellar.model_time.in_(units.Myr))
print("M=", stellar.particles.mass.in_(units.MSun))
print("R=", stellar.particles.radius.in_(units.RSun))
print("L=", stellar.particles.luminosity.in_(units.LSun))
print("T=", stellar.particles.temperature.in_(units.K))
print("Mdot=", \
-stellar.particles.wind_mass_loss_rate.in_(units.MSun/units.yr))
# Start the dynamics.
# Inner binary:
tmp_stars = Particles(2)
tmp_stars[0].mass = M1
tmp_stars[1].mass = M2
if Pora == 1:
ain_0 = semimajor_axis(Pin_0, M1+M2)
else:
Pin_0 = orbital_period(ain_0, M1+M2)
print('Pin =', Pin_0)
print('ain_0 =', ain_0)
print('M1+M2 =', M1+M2)
print('Pin_0 =', Pin_0.value_in(units.day), '[day]')
#print 'semi:', semimajor_axis(Pin_0, M1+M2).value_in(units.AU), 'AU'
#print 'period:', orbital_period(ain_0, M1+M2).value_in(units.day), '[day]'
dt_init = 0.01*Pin_0
ma = 180
inc = 60
aop = 180
lon = 0
r,v = get_position(M1, M2, ein_0, ain_0, ma, inc, aop, lon, dt_init)
tmp_stars[1].position = r
tmp_stars[1].velocity = v
tmp_stars.move_to_center()
# Outer binary:
r,v = get_position(M1+M2, M3, eout_0, aout_0, 0, 0, 0, 0, dt_init)
tertiary = Particle()
tertiary.mass = M3
tertiary.position = r
tertiary.velocity = v
tmp_stars.add_particle(tertiary)
tmp_stars.move_to_center()
triple.position = tmp_stars.position
triple.velocity = tmp_stars.velocity
Mtriple = triple.mass.sum()
Pout = orbital_period(aout_0, Mtriple)
print("T=", stellar.model_time.in_(units.Myr))
print("M=", stellar.particles.mass.in_(units.MSun))
print("Pout=", Pout.in_(units.Myr))
print('tK =', ((M1+M2)/M3)*Pout**2*(1-eout_0**2)**1.5/Pin_0)
converter = nbody_system.nbody_to_si(triple.mass.sum(), aout_0)
if integrator == 0:
gravity = Hermite(converter)
gravity.parameters.timestep_parameter = 0.01
elif integrator == 1:
gravity = SmallN(converter)
gravity.parameters.timestep_parameter = 0.01
gravity.parameters.full_unperturbed = 0
elif integrator == 2:
gravity = Huayno(converter)
gravity.parameters.inttype_parameter = 20
gravity.parameters.timestep = (1./256)*Pin_0
else:
gravity = symple(converter)
gravity.parameters.integrator = 10
#gravity.parameters.timestep_parameter = 0.
gravity.parameters.timestep = (1./128)*Pin_0
print(gravity.parameters)
gravity.particles.add_particles(triple)
channel_from_framework_to_gd = triple.new_channel_to(gravity.particles)
channel_from_gd_to_framework = gravity.particles.new_channel_to(triple)
Etot_init = gravity.kinetic_energy + gravity.potential_energy
Etot_prev = Etot_init
gravity.particles.move_to_center()
# Note: time = t_diag = 0 at the start of the dynamical integration.
dt_diag = t_end/float(nsteps)
t_diag = dt_diag
time = 0.0 | t_end.unit
t_se = t_stellar + time
print('t_end =', t_end)
print('dt_diag =', dt_diag)
ain, ein, aout, eout = get_orbital_elements_of_triple(triple)
print("Triple elements t=", time, \
"inner:", triple[0].mass, triple[1].mass, ain, ein, \
"outer:", triple[2].mass, aout, eout)
t = [time.value_in(units.Myr)]
Mtot = triple.mass.sum()
mtot = [Mtot.value_in(units.MSun)]
smai = [ain/ain_0]
ecci = [ein/ein_0]
smao = [aout/aout_0]
ecco = [eout/eout_0]
if interp:
# Create arrays of stellar times and masses for interpolation.
times = [time]
masses = [triple.mass.copy()]
while time < t_end:
time += dt_se
stellar.evolve_model(t_stellar+time)
channel_from_stellar.copy_attributes(["mass"])
times.append(time)
masses.append(triple.mass.copy())
time = 0.0 | t_end.unit
print('\ntimes:', times, '\n')
# Evolve the system.
def advance_stellar(t_se, dt):
E0 = gravity.kinetic_energy + gravity.potential_energy
t_se += dt
if interp:
t = t_se-t_stellar
i = int(t/dt_se)
mass = masses[i] + (t-times[i])*(masses[i+1]-masses[i])/dt_se
triple.mass = mass
#print 't_se =', t_se, 'masses =', mass
else:
stellar.evolve_model(t_se)
channel_from_stellar.copy_attributes(["mass"])
channel_from_framework_to_gd.copy_attributes(["mass"])
return t_se, gravity.kinetic_energy + gravity.potential_energy - E0
def advance_gravity(tg, dt):
tg += dt
gravity.evolve_model(tg)
channel_from_gd_to_framework.copy()
return tg
while time < t_end:
if scheme == 1:
# Advance to the next diagnostic time.
dE_se = zero
dt = t_diag - time
if dt > 0|dt.unit:
time = advance_gravity(time, dt)
elif scheme == 2:
# Derive dt from Pin using dtse_fac.
dt = dtse_fac*Pin_0
if time + dt > t_diag: dt = t_diag - time
if dt > 0|dt.unit:
t_se, dE_se = advance_stellar(t_se, dt)
time = advance_gravity(time, dt)
elif scheme == 3:
# Derive dt from Pin using dtse_fac.
dt = dtse_fac*Pin_0
if time + dt > t_diag: dt = t_diag - time
if dt > 0|dt.unit:
time = advance_gravity(time, dt)
t_se, dE_se = advance_stellar(t_se, dt)
elif scheme == 4:
# Derive dt from Pin using dtse_fac.
dt = dtse_fac*Pin_0
if time + dt > t_diag: dt = t_diag - time
if dt > 0|dt.unit:
t_se, dE_se = advance_stellar(t_se, 0.5*dt)
time = advance_gravity(time, dt)
t_se, dE_se2 = advance_stellar(t_se, 0.5*dt)
dE_se += dE_se2
elif scheme == 5:
# Use the specified dt_se.
dE_se = zero
dt = dt_se
if time + dt > t_diag: dt = t_diag - time
if dt > 0|dt.unit:
# For use with symple only: set up average mass loss.
channel_from_stellar.copy_attributes(["mass"])
m0 = triple.mass.copy()
stellar.evolve_model(t_se+dt)
channel_from_stellar.copy_attributes(["mass"])
t_se = stellar.model_time
m1 = triple.mass
dmdt = (m1-m0)/dt
for i in range(len(dmdt)):
gravity.set_dmdt(i, dmdt[i])
time = advance_gravity(time, dt)
else:
print('unknown option')
sys.exit(0)
if time >= t_diag:
t_diag = time + dt_diag
Ekin = gravity.kinetic_energy
Epot = gravity.potential_energy
Etot = Ekin + Epot
dE = Etot_prev - Etot
Mtot = triple.mass.sum()
print("T=", time, end=' ')
print("M=", Mtot, "(dM[SE]=", Mtot/Mtriple, ")", end=' ')
print("E= ", Etot, "Q= ", Ekin/Epot, end=' ')
print("dE=", (Etot_init-Etot)/Etot, "ddE=", (Etot_prev-Etot)/Etot, end=' ')
print("(dE[SE]=", dE_se/Etot, ")")
Etot_init -= dE
Etot_prev = Etot
ain, ein, aout, eout = get_orbital_elements_of_triple(triple)
print("Triple elements t=", t_stellar + time, \
"inner:", triple[0].mass, triple[1].mass, ain, ein, \
"outer:", triple[2].mass, aout, eout)
t.append(time.value_in(units.yr))
mtot.append(Mtot.value_in(units.MSun))
smai.append(ain/ain_0)
ecci.append(ein/ein_0)
smao.append(aout/aout_0)
ecco.append(eout/eout_0)
if eout > 1 or aout <= zero:
print("Binary ionized or merged")
break
gravity.stop()
stellar.stop()
return t, mtot, smai, ecci, smao, ecco
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun, 149.5e6 | units.km)
huayno = Huayno(convert_nbody)
huayno.initialize_code()
huayno.parameters.epsilon_squared = 0.0 | units.AU**2
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
huayno.particles.add_particles(stars)
huayno.evolve_model(365.0 | units.day)
huayno.particles.copy_values_of_all_attributes_to(stars)
position_at_start = earth.position.value_in(units.AU)[0]
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation, 6)
huayno.evolve_model(365.0 + (365.0 / 2) | units.day)
huayno.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 2)
huayno.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
huayno.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-position_at_start, position_after_half_a_rotation, 3)
huayno.cleanup_code()
huayno.stop()
def test1(self):
convert_nbody = nbody_system.nbody_to_si(1.0 | units.MSun,
149.5e6 | units.km)
huayno = Huayno(convert_nbody)
huayno.initialize_code()
huayno.parameters.epsilon_squared = 0.0 | units.AU**2
stars = self.new_system_of_sun_and_earth()
earth = stars[1]
huayno.particles.add_particles(stars)
huayno.evolve_model(365.0 | units.day)
huayno.particles.copy_values_of_all_attributes_to(stars)
position_at_start = earth.position.value_in(units.AU)[0]
position_after_full_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(position_at_start, position_after_full_rotation,
6)
huayno.evolve_model(365.0 + (365.0 / 2) | units.day)
huayno.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[0]
self.assertAlmostEqual(-position_at_start,
position_after_half_a_rotation, 2)
huayno.evolve_model(365.0 + (365.0 / 2) + (365.0 / 4) | units.day)
huayno.particles.copy_values_of_all_attributes_to(stars)
position_after_half_a_rotation = earth.position.value_in(units.AU)[1]
self.assertAlmostEqual(-position_at_start,
position_after_half_a_rotation, 3)
huayno.cleanup_code()
huayno.stop()
