def generate_formation_snapshot(t):
""""""
orbit = get_orbit()
ind = orbit.t <= t
orbit = orbit[ind]
np.random.seed(49382)
t_disrupt = -300 * u.Myr
minit = 7e4
mfin = 1e3
nrelease = 1
prog_orbit = orbit
if np.size(orbit.t) > 1:
n_times = (prog_orbit.t < t_disrupt).sum()
prog_mass = np.linspace(minit, mfin, n_times)
prog_mass = np.concatenate(
(prog_mass, np.zeros(len(prog_orbit.t) - n_times))) * u.Msun
model = mockstream.dissolved_fardal_stream(ham,
prog_orbit,
prog_mass=prog_mass,
t_disrupt=t_disrupt,
release_every=nrelease)
c = coord.Galactocentric(x=model.x, y=model.y, z=model.z)
else:
c = coord.Galactocentric(x=orbit.x, y=orbit.y, z=orbit.z)
return (orbit, c)
def plain_model():
"""Unperturbed model of GD-1"""
np.random.seed(143531)
t_impact, M, rs, bnorm, bx, vnorm, vx = impact_params()
dt_orbit = 0.5 * u.Myr
nstep_impact = np.int64(t_impact / dt_orbit)
prog_orbit = get_orbit()
wangle = 180 * u.deg
t_disrupt = -300 * u.Myr
minit = 7e4
mfin = 1e3
nrelease = 1
n_times = (prog_orbit.t < t_disrupt).sum()
prog_mass = np.linspace(minit, mfin, n_times)
prog_mass = np.concatenate(
(prog_mass, np.zeros(len(prog_orbit.t) - n_times))) * u.Msun
# stream model at the present
model = mockstream.dissolved_fardal_stream(
ham,
prog_orbit,
prog_mass=prog_mass,
t_disrupt=t_disrupt,
release_every=nrelease,
snapshot_filename='../data/model_unperturbed.h5')
# angular coordinates
r = np.sqrt(model.x**2 + model.y**2 + model.z**2)
theta = np.arccos(model.z / r)
phi = coord.Angle(np.arctan2(model.y, model.x)).wrap_at(0 * u.deg)
# sky coordinates
c = coord.Galactocentric(x=model.x, y=model.y, z=model.z)
ceq = c.transform_to(coord.ICRS)
cgd = c.transform_to(gc.GD1)
plt.close()
fig, ax = plt.subplots(3, 1, figsize=(8, 8))
plt.sca(ax[0])
plt.plot(model.y, model.z, 'k.', ms=1)
plt.plot(model.y[::2], model.z[::2], 'r.', ms=1)
plt.sca(ax[1])
#plt.plot(phi, theta, 'k.', ms=1)
plt.plot(ceq.ra, ceq.dec, 'k.', ms=1)
plt.plot(ceq.ra[::2], ceq.dec[::2], 'r.', ms=1)
plt.sca(ax[2])
plt.plot(cgd.phi1.wrap_at(180 * u.deg), cgd.phi2, 'k.', ms=1)
plt.plot(cgd.phi1[::2].wrap_at(180 * u.deg), cgd.phi2[::2], 'r.', ms=1)
plt.tight_layout()
def plot_fullorbit():
""""""
orbit = get_orbit()
ind = orbit.t < -2.2 * u.Gyr
orbit = orbit[ind]
t_disrupt = -300 * u.Myr
minit = 7e4
mfin = 1e3
nrelease = 1
prog_orbit = orbit
n_times = (prog_orbit.t < t_disrupt).sum()
prog_mass = np.linspace(minit, mfin, n_times)
prog_mass = np.concatenate(
(prog_mass, np.zeros(len(prog_orbit.t) - n_times))) * u.Msun
model = mockstream.dissolved_fardal_stream(ham,
prog_orbit,
prog_mass=prog_mass,
t_disrupt=t_disrupt,
release_every=nrelease)
# sky coordinates
c = coord.Galactocentric(x=model.x, y=model.y, z=model.z)
plt.close()
fig = plt.figure(figsize=(16, 9))
fig.add_subplot(111, position=[0, 0, 1, 1])
#plt.plot(orbit.y[0], orbit.z[0], 'ro')
pdisk = mpl.patches.Ellipse((0, 0), 30, 0.3, color='orange')
patch = plt.gca().add_patch(pdisk)
plt.plot(-8.3, 0, '*', color='darkorange', ms=30)
plt.plot(orbit.x[-1], orbit.z[-1], 'ko', ms=10)
plt.plot(orbit.x, orbit.z, 'k-', alpha=0.3)
plt.plot(c.x, c.z, 'k.', ms=4, alpha=0.1)
plt.text(0.05,
0.9,
'{:4.0f} million years'.format(
(orbit.t[-1] - orbit.t[0]).to(u.Myr).value),
transform=plt.gca().transAxes,
fontsize=20)
dx = 30
dy = dx * 9 / 16
plt.xlim(-dx, dx)
plt.ylim(-dy, dy)
plt.gca().axis('off')
plt.gca().tick_params(labelbottom=False, labelleft=False)
def fiducial_at_encounter():
"""Create fiducial model at the time of encounter"""
np.random.seed(143531)
t_impact = 0.495 * u.Gyr
bnorm = 15 * u.pc
bx = 6 * u.pc
vnorm = 250 * u.km / u.s
vx = -25 * u.km / u.s
# load one orbital point
pos = np.load('../data/log_orbit.npy')
phi1, phi2, d, pm1, pm2, vr = pos
c = gc.GD1(phi1=phi1 * u.deg,
phi2=phi2 * u.deg,
distance=d * u.kpc,
pm_phi1_cosphi2=pm1 * u.mas / u.yr,
pm_phi2=pm2 * u.mas / u.yr,
radial_velocity=vr * u.km / u.s)
w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)
# best-fitting orbit
dt = 0.5 * u.Myr
n_steps = 120
wangle = 180 * u.deg
# integrate back in time
fit_orbit = ham.integrate_orbit(w0, dt=dt, n_steps=n_steps)
prog_phi0 = -20 * u.deg
model_gd1 = fit_orbit.to_coord_frame(gc.GD1, galactocentric_frame=gc_frame)
prog_i = np.abs(model_gd1.phi1.wrap_at(180 * u.deg) - prog_phi0).argmin()
prog_w0 = fit_orbit[prog_i]
dt_orbit = 0.5 * u.Myr
nstep_impact = np.int64((t_impact / dt_orbit).decompose())
#prog_orbit = ham.integrate_orbit(prog_w0, dt=-dt_orbit, t1=0*u.Myr, t2=-3*u.Gyr)
prog_orbit = ham.integrate_orbit(prog_w0,
dt=-dt_orbit,
t1=0 * u.Myr,
t2=-3 * u.Gyr)
impact_orbit = prog_orbit[nstep_impact:]
impact_orbit = impact_orbit[::-1]
prog_orbit = prog_orbit[::-1]
t_disrupt = -300 * u.Myr
minit = 7e4
mfin = 1e3
nrelease = 1
n_times = (prog_orbit.t < t_disrupt).sum()
prog_mass = np.linspace(minit, mfin, n_times)
prog_mass = np.concatenate(
(prog_mass, np.zeros(len(prog_orbit.t) - n_times))) * u.Msun
model_present = mockstream.dissolved_fardal_stream(ham,
prog_orbit,
prog_mass=prog_mass,
t_disrupt=t_disrupt,
release_every=nrelease)
n_steps_disrupt = int(abs(t_disrupt / (prog_orbit.t[1] - prog_orbit.t[0])))
model_present = model_present[:-2 * n_steps_disrupt]
model_gd1 = model_present.to_coord_frame(gc.GD1,
galactocentric_frame=gc_frame)
ind_gap = np.where((model_gd1.phi1.wrap_at(wangle) > -43 * u.deg)
& (model_gd1.phi1.wrap_at(wangle) < -33 * u.deg))[0]
n_times = (impact_orbit.t < t_disrupt).sum()
prog_mass = np.linspace(minit, mfin, n_times)
prog_mass = np.concatenate(
(prog_mass, np.zeros(len(impact_orbit.t) - n_times))) * u.Msun
model = mockstream.dissolved_fardal_stream(ham,
impact_orbit,
prog_mass=prog_mass,
t_disrupt=t_disrupt,
release_every=nrelease)
n_steps_disrupt = int(
abs(t_disrupt / (impact_orbit.t[1] - impact_orbit.t[0])))
model = model[:-2 * n_steps_disrupt]
Nstar = np.shape(model)[0]
ivalid = ind_gap < Nstar
ind_gap = ind_gap[ivalid]
xgap = np.median(model.xyz[:, ind_gap], axis=1)
vgap = np.median(model.v_xyz[:, ind_gap], axis=1)
########################
# Perturber at encounter
i = np.array([1, 0, 0], dtype=float)
j = np.array([0, 1, 0], dtype=float)
k = np.array([0, 0, 1], dtype=float)
# find positional plane
bi = np.cross(j, vgap)
bi = bi / np.linalg.norm(bi)
bj = np.cross(vgap, bi)
bj = bj / np.linalg.norm(bj)
# pick b
by = np.sqrt(bnorm**2 - bx**2)
b = bx * bi + by * bj
xsub = xgap + b
# find velocity plane
vi = np.cross(vgap, b)
vi = vi / np.linalg.norm(vi)
vj = np.cross(b, vi)
vj = vj / np.linalg.norm(vj)
# pick v
vy = np.sqrt(vnorm**2 - vx**2)
vsub = vx * vi + vy * vj
outdict = {'model': model, 'xsub': xsub, 'vsub': vsub}
pickle.dump(outdict, open('../data/fiducial_at_encounter.pkl', 'wb'))
def fiducial_at_start():
"""Create fiducial model at the beginning of the movie"""
np.random.seed(143531)
t_impact = 2 * 0.495 * u.Gyr
# load one orbital point
pos = np.load('../data/log_orbit.npy')
phi1, phi2, d, pm1, pm2, vr = pos
c = gc.GD1(phi1=phi1 * u.deg,
phi2=phi2 * u.deg,
distance=d * u.kpc,
pm_phi1_cosphi2=pm1 * u.mas / u.yr,
pm_phi2=pm2 * u.mas / u.yr,
radial_velocity=vr * u.km / u.s)
w0 = gd.PhaseSpacePosition(c.transform_to(gc_frame).cartesian)
# best-fitting orbit
dt = 0.5 * u.Myr
n_steps = 120
wangle = 180 * u.deg
# integrate back in time
fit_orbit = ham.integrate_orbit(w0, dt=dt, n_steps=n_steps)
prog_phi0 = -20 * u.deg
model_gd1 = fit_orbit.to_coord_frame(gc.GD1, galactocentric_frame=gc_frame)
prog_i = np.abs(model_gd1.phi1.wrap_at(180 * u.deg) - prog_phi0).argmin()
prog_w0 = fit_orbit[prog_i]
dt_orbit = 0.5 * u.Myr
nstep_impact = np.int64((t_impact / dt_orbit).decompose())
#prog_orbit = ham.integrate_orbit(prog_w0, dt=-dt_orbit, t1=0*u.Myr, t2=-3*u.Gyr)
prog_orbit = ham.integrate_orbit(prog_w0,
dt=-dt_orbit,
t1=0 * u.Myr,
t2=-3 * u.Gyr)
impact_orbit = prog_orbit[nstep_impact:]
impact_orbit = impact_orbit[::-1]
prog_orbit = prog_orbit[::-1]
t_disrupt = -300 * u.Myr
minit = 7e4
mfin = 1e3
nrelease = 1
n_times = (prog_orbit.t < t_disrupt).sum()
prog_mass = np.linspace(minit, mfin, n_times)
prog_mass = np.concatenate(
(prog_mass, np.zeros(len(prog_orbit.t) - n_times))) * u.Msun
model_present = mockstream.dissolved_fardal_stream(ham,
prog_orbit,
prog_mass=prog_mass,
t_disrupt=t_disrupt,
release_every=nrelease)
n_steps_disrupt = int(abs(t_disrupt / (prog_orbit.t[1] - prog_orbit.t[0])))
model_present = model_present[:-2 * n_steps_disrupt]
model_gd1 = model_present.to_coord_frame(gc.GD1,
galactocentric_frame=gc_frame)
ind_gap = np.where((model_gd1.phi1.wrap_at(wangle) > -43 * u.deg)
& (model_gd1.phi1.wrap_at(wangle) < -33 * u.deg))[0]
n_times = (impact_orbit.t < t_disrupt).sum()
prog_mass = np.linspace(minit, mfin, n_times)
prog_mass = np.concatenate(
(prog_mass, np.zeros(len(impact_orbit.t) - n_times))) * u.Msun
model = mockstream.dissolved_fardal_stream(ham,
impact_orbit,
prog_mass=prog_mass,
t_disrupt=t_disrupt,
release_every=nrelease)
n_steps_disrupt = int(
abs(t_disrupt / (impact_orbit.t[1] - impact_orbit.t[0])))
model = model[:-2 * n_steps_disrupt]
xsub = np.ones(3) * u.kpc
vsub = np.ones(3) * u.km / u.s
outdict = {'model': model, 'xsub': xsub, 'vsub': vsub}
pickle.dump(outdict, open('../data/fiducial_at_start.pkl', 'wb'))
def fiducial_model():
""""""
np.random.seed(143531)
t_impact, M, rs, bnorm, bx, vnorm, vx = impact_params()
dt_orbit = 0.5 * u.Myr
nstep_impact = np.int64((t_impact / dt_orbit).decompose())
prog_orbit = get_orbit()
wangle = 180 * u.deg
t_disrupt = -300 * u.Myr
minit = 7e4
mfin = 1e3
nrelease = 1
n_times = (prog_orbit.t < t_disrupt).sum()
prog_mass = np.linspace(minit, mfin, n_times)
prog_mass = np.concatenate(
(prog_mass, np.zeros(len(prog_orbit.t) - n_times))) * u.Msun
model_present = mockstream.dissolved_fardal_stream(ham,
prog_orbit,
prog_mass=prog_mass,
t_disrupt=t_disrupt,
release_every=nrelease)
n_steps_disrupt = int(abs(t_disrupt / (prog_orbit.t[1] - prog_orbit.t[0])))
model_present = model_present[:-2 * n_steps_disrupt]
model_gd1 = model_present.to_coord_frame(gc.GD1,
galactocentric_frame=gc_frame)
ind_gap = np.where((model_gd1.phi1.wrap_at(wangle) > -43 * u.deg)
& (model_gd1.phi1.wrap_at(wangle) < -33 * u.deg))[0]
prog_orbit = prog_orbit[::-1]
impact_orbit = prog_orbit[nstep_impact:]
impact_orbit = impact_orbit[::-1]
n_times = (impact_orbit.t < t_disrupt).sum()
prog_mass = np.linspace(minit, mfin, n_times)
prog_mass = np.concatenate(
(prog_mass, np.zeros(len(impact_orbit.t) - n_times))) * u.Msun
model = mockstream.dissolved_fardal_stream(ham,
impact_orbit,
prog_mass=prog_mass,
t_disrupt=t_disrupt,
release_every=nrelease)
n_steps_disrupt = int(
abs(t_disrupt / (impact_orbit.t[1] - impact_orbit.t[0])))
model = model[:-2 * n_steps_disrupt]
Nstar = np.shape(model)[0]
ivalid = ind_gap < Nstar
ind_gap = ind_gap[ivalid]
xgap = np.median(model.xyz[:, ind_gap], axis=1)
vgap = np.median(model.v_xyz[:, ind_gap], axis=1)
########################
# Perturber at encounter
i = np.array([1, 0, 0], dtype=float)
j = np.array([0, 1, 0], dtype=float)
k = np.array([0, 0, 1], dtype=float)
# find positional plane
bi = np.cross(j, vgap)
bi = bi / np.linalg.norm(bi)
bj = np.cross(vgap, bi)
bj = bj / np.linalg.norm(bj)
# pick b
by = np.sqrt(bnorm**2 - bx**2)
b = bx * bi + by * bj
xsub = xgap + b
# find velocity plane
vi = np.cross(vgap, b)
vi = vi / np.linalg.norm(vi)
vj = np.cross(b, vi)
vj = vj / np.linalg.norm(vj)
# pick v
vy = np.sqrt(vnorm**2 - vx**2)
vsub = vx * vi + vy * vj
# impact parameters
Tenc = 0.01 * u.Gyr
dt = 0.05 * u.Myr
# potential parameters
potential = 3
Vh = 225 * u.km / u.s
q = 1 * u.Unit(1)
rhalo = 0 * u.pc
par_pot = np.array([Vh.si.value, q.value, rhalo.si.value])
# generate unperturbed stream model
#potential_perturb = 2
#par_perturb = np.array([0*M.si.value, rs.si.value, 0, 0, 0])
#x1, x2, x3, v1, v2, v3 = interact.general_interact(par_perturb, xsub.si.value, vsub.si.value, Tenc.si.value, t_impact.si.value, dt.si.value, par_pot, potential, potential_perturb, model.x.si.value, model.y.si.value, model.z.si.value, model.v_x.si.value, model.v_y.si.value, model.v_z.si.value)
#stream = {}
#stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)
#stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)
#c = coord.Galactocentric(x=stream['x'][0], y=stream['x'][1], z=stream['x'][2], v_x=stream['v'][0], v_y=stream['v'][1], v_z=stream['v'][2], **gc_frame_dict)
#cg = c.transform_to(gc.GD1)
#wangle = 180*u.deg
#outdict = {'cg': cg}
#pickle.dump(outdict, open('../data/fiducial_noperturb.pkl', 'wb'))
# generate perturbed stream model
potential_perturb = 2
par_perturb = np.array([M.si.value, rs.si.value, 0, 0, 0])
x1, x2, x3, v1, v2, v3 = interact.general_interact(
par_perturb, xsub.si.value, vsub.si.value, Tenc.si.value,
t_impact.si.value, dt.si.value, par_pot, potential, potential_perturb,
model.x.si.value, model.y.si.value, model.z.si.value,
model.v_x.si.value, model.v_y.si.value, model.v_z.si.value)
stream = {}
stream['x'] = (np.array([x1, x2, x3]) * u.m).to(u.kpc)
stream['v'] = (np.array([v1, v2, v3]) * u.m / u.s).to(u.km / u.s)
c = coord.Galactocentric(x=stream['x'][0],
y=stream['x'][1],
z=stream['x'][2],
v_x=stream['v'][0],
v_y=stream['v'][1],
v_z=stream['v'][2],
**gc_frame_dict)
cg = c.transform_to(gc.GD1)
wangle = 180 * u.deg
#outdict = {'cg': cg}
#pickle.dump(outdict, open('../data/fiducial_perturb.pkl', 'wb'))
#plt.close()
#plt.plot(stream['x'][1], stream['x'][2], 'k.')
plt.close()
plt.figure(figsize=(10, 5))
plt.plot(cg.phi1.wrap_at(180 * u.deg), cg.phi2, 'k.', ms=1)
plt.xlim(-80, 0)
plt.ylim(-10, 10)
plt.tight_layout()