def test8(self):
print("Testing FastKick for Bridge: potential energy")
numpy.random.seed(12345)
stars = new_plummer_model(100)
cluster = new_gravity_code(stars)
first_half = stars.select_array(
lambda x: (x > 0 | nbody_system.length), ['x'])
second_half = stars - first_half
cluster1 = new_gravity_code(first_half)
cluster2 = new_gravity_code(second_half)
kick_from_cluster1 = CalculateFieldForCodesUsingReinitialize(
self.new_fastkick_instance(), (cluster1, ))
kick_from_cluster2 = CalculateFieldForCodesUsingReinitialize(
self.new_fastkick_instance(), (cluster2, ))
bridgesys = Bridge()
bridgesys.add_system(cluster1, (kick_from_cluster2, ))
bridgesys.add_system(cluster2, (kick_from_cluster1, ))
self.assertAlmostRelativeEqual(cluster.potential_energy,
bridgesys.potential_energy, 7)
self.assertAlmostRelativeEqual(cluster.kinetic_energy,
bridgesys.kinetic_energy)
kick_from_cluster1.code.stop()
kick_from_cluster2.code.stop()
def new_gravity_field_from_gas(hydro_code, gravity_field_code):
gravity_field = CalculateFieldForCodesUsingReinitialize(
gravity_field_code,
[hydro_code],
required_attributes=['mass', 'x', 'y', 'z', 'vx', 'vy', 'vz', 'u']
) # "u" isn't really required, but get_state_sph is faster than get_mass+get_position+get_velocity
return gravity_field
def test9(self):
print("Testing FastKick for Bridge: evolving a binary")
particles = Particles(2)
particles.mass = [3.0, 1.0] | units.MSun
particles.position = [0, 0, 0] | units.AU
particles.velocity = [0, 0, 0] | units.km / units.s
particles[1].x = 2.0 | units.AU
particles[1].vy = (constants.G * (4.0 | units.MSun) /
(2.0 | units.AU)).sqrt()
particles.move_to_center()
primary_sys = new_gravity_code(particles[:1])
secondary_sys = new_gravity_code(particles[1:])
primary = primary_sys.particles[0]
P = 2 * math.pi * primary.x / primary.vy
converter = nbody_system.nbody_to_si(1.0 | units.MSun, 1.0 | units.AU)
kick_from_primary = CalculateFieldForCodesUsingReinitialize(
self.new_fastkick_instance(converter), (primary_sys, ))
kick_from_secondary = CalculateFieldForCodesUsingReinitialize(
self.new_fastkick_instance(converter), (secondary_sys, ))
bridgesys = Bridge(timestep=P / 64.0)
bridgesys.add_system(primary_sys, (kick_from_secondary, ))
bridgesys.add_system(secondary_sys, (kick_from_primary, ))
position_at_start = primary.position.x
bridgesys.evolve_model(P / 4.0)
self.assertAlmostRelativeEqual(position_at_start, primary.position.y,
2)
bridgesys.evolve_model(P / 2.0)
self.assertAlmostRelativeEqual(position_at_start, -primary.position.x,
2)
bridgesys.evolve_model(P)
kick_from_primary.code.stop()
kick_from_secondary.code.stop()
self.assertAlmostRelativeEqual(position_at_start, primary.position.x,
2)
def new_coupled_system(hydro, binary_system, t_end, n_steps):
kick_from_hydro = CalculateFieldForParticles(particles=hydro.particles, gravity_constant=constants.G)
kick_from_hydro.smoothing_length_squared = 100 | units.RSun**2
unit_converter = nbody_system.nbody_to_si(binary_system.particles.total_mass(), t_end)
kicker_code = MI6(unit_converter, redirection='file', redirect_file='kicker_code_mi6_out.log')
kicker_code.parameters.epsilon_squared = 100 | units.RSun**2
kick_from_binary = CalculateFieldForCodesUsingReinitialize(kicker_code, (binary_system,))
coupled_system = Bridge(timestep=(t_end / (2 * n_steps)), verbose=False, use_threading=True)
coupled_system.add_system(binary_system, (kick_from_hydro,), False)
coupled_system.add_system(hydro, (kick_from_binary,), False)
return coupled_system
def new_gravity_field_from(codes, converter, epsilon_squared):
gravity_field_code = Octgrav(
converter,
node_label="GPU",
redirection="file",
redirect_file="gravity_field_code{0}.log".format(
new_gravity_field_from.counter))
gravity_field_code.parameters.epsilon_squared = epsilon_squared
gravity_field_code.parameters.opening_angle = 0.5
gravity_field = CalculateFieldForCodesUsingReinitialize(
gravity_field_code,
codes,
required_attributes=['mass', 'x', 'y', 'z', 'vx', 'vy', 'vz'])
new_gravity_field_from.counter += 1
return gravity_field
def __init__(self,
grav_code,
gas_code,
se_code,
grav_couple_code,
conv,
mgas,
star_parts,
gas_parts,
dt_feedback,
dt_fast,
grav_parameters=(),
gas_parameters=(),
couple_parameters=(),
feedback_efficiency=.01,
feedback_radius=0.01 | units.parsec,
total_feedback_energy=zero,
evo_particles=None,
star_particles_addition=None,
start_time_offset=zero,
feedback_safety=1.e-4 * 1.e51 | units.erg,
feedback_dt=(10. | units.yr, 7500. | units.yr),
feedback_period=20000. | units.yr,
feedback_lasttime=None,
grav_code_extra=dict(mode='gpu', redirection='none'),
gas_code_extra=dict(number_of_workers=3,
use_gl=False,
redirection='none'),
se_code_extra=dict(redirection='none'),
grav_couple_code_extra=dict()):
self.codes = (gas_code, grav_code, se_code, grav_couple_code)
self.parameters = (grav_parameters, gas_parameters, couple_parameters)
self.conv = conv
self.sph = sys_from_parts(gas_code,
gasparts=gas_parts,
parameters=gas_parameters,
converter=conv,
extra=gas_code_extra)
self.grav = sys_from_parts(grav_code,
parts=star_parts,
parameters=grav_parameters,
converter=conv,
extra=grav_code_extra)
print gas_parameters
print
print self.sph.parameters
#~self.sph_grav=reinitializecopycat(grav_couple_code, (self.sph,self.grav), conv,
#~parameters=couple_parameters, extra=grav_couple_code_extra)
#~self.star_grav=reinitializecopycat(grav_couple_code, (self.sph,), conv,
#~parameters=couple_parameters, extra=grav_couple_code_extra)
new_couple_code1 = grav_couple_code(conv, **grav_couple_code_extra)
for param, value in couple_parameters:
new_couple_code1.parameters.__setattr__(param, value)
self.sph_grav = CalculateFieldForCodesUsingReinitialize(
new_couple_code1, (self.sph, self.grav))
new_couple_code2 = grav_couple_code(conv, **grav_couple_code_extra)
for param, value in couple_parameters:
new_couple_code2.parameters.__setattr__(param, value)
self.star_grav = CalculateFieldForCodesUsingReinitialize(
new_couple_code2, (self.sph, ))
self.fast = Bridge(verbose=True, timestep=dt_fast)
self.fast.add_system(self.sph, (self.sph_grav, ), False)
self.fast.add_system(self.grav, (self.star_grav, ), False)
self.evo = se_code(**se_code_extra)
self.evo.initialize_module_with_default_parameters()
if evo_particles is None:
self.evo.particles.add_particles(star_parts)
else:
if len(evo_particles) != len(star_parts):
print "evo parts != star parts"
raise Exception
self.evo.particles.add_particles(evo_particles)
self.total_feedback_energy = total_feedback_energy
self.dt_feedback = dt_feedback
self.dt_fast = dt_fast
self.mgas = mgas
self.time = self.fast.model_time + start_time_offset
self.time_offset = start_time_offset
if star_particles_addition is None:
self.star_particles_addition = star_parts.empty_copy()
self.star_particles_addition.Emech_last_feedback = 0. | units.erg
else:
self.star_particles_addition = star_particles_addition
self.feedback_efficiency = feedback_efficiency
self.feedback_radius = feedback_radius
self.feedback_safety = feedback_safety
self.feedback_dt = feedback_dt
self.feedback_period = feedback_period
if self.feedback_period < 1.0001 * self.dt_feedback:
print "feedback_period < dt_feedback, resetting to dt_feedback=", \
self.dt_feedback.in_(units.yr)
self.feedback_period = 1.0001 * self.dt_feedback
if feedback_lasttime is None:
self.feedback_lasttime = self.time - 2 * self.feedback_period
else:
self.feedback_lasttime = feedback_lasttime