def run_kepler(mass, semi, ecc, time):
kep = Kepler(redirection='none')
kep.initialize_code()
kep.set_longitudinal_unit_vector(1.0, 1.0,
0.0)
kep.initialize_from_elements(mass, semi, ecc)
a,e = kep.get_elements()
p = kep.get_periastron()
print "elements:", a, e, p
kep.transform_to_time(time)
x,y,z = kep.get_separation_vector()
print "separation:", x,y,z
x,y,z = kep.get_longitudinal_unit_vector()
print "longitudinal:", x,y,z
pos = [1, 0, 0] | nbody_system.length
vel = [0, 0.5, 0] | nbody_system.speed
kep.initialize_from_dyn(mass, pos[0], pos[1], pos[2],
vel[0], vel[1], vel[2])
a,e = kep.get_elements()
p = kep.get_periastron()
print "elements:", a, e, p
kep.transform_to_time(time)
x,y,z = kep.get_separation_vector()
print "separation:", x,y,z
x,y,z = kep.get_velocity_vector()
print "velocity:", x,y,z
x,y,z = kep.get_longitudinal_unit_vector()
print "longitudinal:", x,y,z
kep.set_random(42)
kep.make_binary_scattering(0.5 | nbody_system.mass,
0.5,
0.5 | nbody_system.mass,
0.0 | nbody_system.speed,
0.0 | nbody_system.length,
1.e-6,
0)
kep.stop()
def CutOrAdvance(enc_bodies, primary_sysID, converter=None):
bodies = enc_bodies.copy()
if converter==None:
converter = nbody_system.nbody_to_si(bodies.mass.sum(), 2 * np.max(bodies.radius.number) | bodies.radius.unit)
systems = stellar_systems.get_heirarchical_systems_from_set(bodies, converter=converter, RelativePosition=False)
# Deal with Possible Key Issues with Encounters with 3+ Star Particles Being Run More than Other Systems ...
if int(primary_sysID) not in systems.keys():
print "...: Error: Previously run binary system has been found! Not running this system ..."
print primary_sysID
print systems.keys()
print "---------------------------------"
return None
# As this function is pulling from Multiples, there should never be more or less than 2 "Root" Particles ...
if len(systems) != 2:
print "...: Error: Encounter has more roots than expected! Total Root Particles:", len(systems)
print bodies
print "---------------------------------"
return None
# Assign the Primary System to #1 and Perturbing System to #2
sys_1 = systems[int(primary_sysID)]
secondary_sysID = [key for key in systems.keys() if key!=int(primary_sysID)][0]
sys_2 = systems[secondary_sysID]
print 'All System Keys:', systems.keys()
print 'Primary System Key:', primary_sysID
print 'System 1 IDs:', sys_1.id
print 'System 2 IDs:', sys_2.id
# Calculate Useful Quantities
mass_ratio = sys_2.mass.sum()/sys_1.mass.sum()
total_mass = sys_1.mass.sum() + sys_2.mass.sum()
rel_pos = sys_1.center_of_mass() - sys_2.center_of_mass()
rel_vel = sys_1.center_of_mass_velocity() - sys_2.center_of_mass_velocity()
# Initialize Kepler Worker
kep = Kepler(unit_converter = converter, redirection = 'none')
kep.initialize_code()
kep.initialize_from_dyn(total_mass, rel_pos[0], rel_pos[1], rel_pos[2], rel_vel[0], rel_vel[1], rel_vel[2])
# Check to See if the Periastron is within the Ignore Distance for 10^3 Perturbation
p = kep.get_periastron()
ignore_distance = mass_ratio**(1./3.) * 600 | units.AU
if p > ignore_distance:
print "Encounter Ignored due to Periastron of", p.in_(units.AU), "and an IgnoreDistance of",ignore_distance
kep.stop()
print "---------------------------------"
return None
# Move the Particles to be Relative to their Respective Center of Mass
cm_sys_1, cm_sys_2 = sys_1.center_of_mass(), sys_2.center_of_mass()
cmv_sys_1, cmv_sys_2 = sys_1.center_of_mass_velocity(), sys_2.center_of_mass_velocity()
for particle in sys_1:
particle.position -= cm_sys_1
particle.velocity -= cmv_sys_1
for particle in sys_2:
particle.position -= cm_sys_2
particle.velocity -= cmv_sys_2
# Check to See if the Planets are Closer than the Ignore Distance
# Note: This shouldn't happen in the main code, but this prevents overshooting the periastron in debug mode.
if kep.get_separation() > ignore_distance:
kep.advance_to_radius(ignore_distance)
# Advance the Center of Masses to the Desired Distance in Reduced Mass Coordinates
x, y, z = kep.get_separation_vector()
rel_pos_f = rel_pos.copy()
rel_pos_f[0], rel_pos_f[1], rel_pos_f[2] = x, y, z
vx, vy, vz = kep.get_velocity_vector()
rel_vel_f = rel_vel.copy()
rel_vel_f[0], rel_vel_f[1], rel_vel_f[2] = vx, vy, vz
# Transform to Absolute Coordinates from Kepler Reduced Mass Coordinates
cm_pos_1, cm_pos_2 = sys_2.mass.sum() * rel_pos_f / total_mass, -sys_1.mass.sum() * rel_pos_f / total_mass
cm_vel_1, cm_vel_2 = sys_2.mass.sum() * rel_vel_f / total_mass, -sys_1.mass.sum() * rel_vel_f / total_mass
# Move the Particles to the New Postions of their Respective Center of Mass
for particle in sys_1:
particle.position += cm_pos_1
particle.velocity += cm_vel_1
for particle in sys_2:
particle.position += cm_pos_2
particle.velocity += cm_vel_2
# Stop Kepler and Return the Systems as a Particle Set
kep.stop()
# Collect the Collective Particle Set to be Returned Back
final_set = Particles()
final_set.add_particles(sys_1)
final_set.add_particles(sys_2)
print "---------------------------------"
return final_set
sun_and_stone = Particles(2)
sun_and_stone[0].position = [-5.40085336308e+13, -5.92288255636e+13, 0.
] | units.m
sun_and_stone[0].velocity = [-68.4281023588, -90.213640012, 0.
] | (units.m / units.s)
sun_and_stone[0].mass = 1.98892e+30 | units.kg
sun_and_stone[1].position = [2.31421952844e+17, 1.72742642121e+17, 0.
] | units.m
sun_and_stone[1].velocity = [500794.477878, 373808.365427, 0.
] | (units.m / units.s)
sun_and_stone[1].mass = 0. | units.kg
print " particles:"
print sun_and_stone
converter = nbody_system.nbody_to_si(1 | units.MSun, 1 | units.AU)
kepler = Kepler(converter)
kepler.initialize_code()
kepler.initialize_from_particles(sun_and_stone)
semi, ecc = kepler.get_elements()
apo = kepler.get_apastron()
per = kepler.get_periastron()
period = kepler.get_period()
kepler.stop()
print " semi-major axis ", semi.in_(units.AU)
print " eccentricity ", ecc
print " apocenter ", apo.in_(units.AU)
print " pericenter ", per.in_(units.AU)
print " period", period
