def simple_rho(this_looper,core_list=None):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr=this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times=thtr.times[mask]/colors.tff
rho_all = thtr.track_dict['density']
rho_min=rho_all.min()
rho_max=rho_all.max()
for core_id in core_list:
fig,ax=plt.subplots(1,1)
quan = thtr.c([core_id],'density')[:,mask]
bins = np.geomspace(rho_min,rho_max,64)
XX,YY,HH,VV,plot=heat_map.heat_map( quan, times, ax=ax, bins=bins,hist_norm=True, zlim=[5e-3,3e-1])
axbonk(ax,xlabel=r'$t/t_{ff}$', ylabel=r'$\rho/\rho_0$',yscale='log')
norm = mpl.colors.LogNorm( HH[HH>0].min(), HH.max())
fig.colorbar(plot)
outname='plots_to_sort/%s_rho_t_heat_c%04d.png'%(this_looper.sim_name,core_id)
fig.savefig(outname)
print(outname)
def simple_rho(this_looper, core_list=None):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr = this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times = thtr.times[mask] + 0 #the zero makes a copy
times.shape = times.size, 1
times = times / colors.tff
rho_all = thtr.track_dict['density']
rho_min = rho_all.min()
rho_max = rho_all.max()
B_all = thtr.track_dict['magnetic_field_strength']
B_min = B_all.min()
B_max = B_all.max()
for core_id in core_list:
fig, ax_square = plt.subplots(2, 2)
ax = ax_square.flatten()
ms = trackage.mini_scrubber(thtr, core_id, do_velocity=False)
ms.particle_pos(core_id)
if ms.nparticles < 1000:
sl = slice(None)
c = [0.5] * 4
else:
sl = slice(None, None, 10)
#c=[0,0,0,0.1]
c = [0.1] * 4
rho = ms.density[sl].transpose()
rho = rho[mask, :]
B = thtr.c([core_id], 'magnetic_field_strength')[sl].transpose()[
mask, :] #/colors.mean_field[this_looper.sim_name]
ax[0].plot(times, rho, c=c, linewidth=0.1)
axbonk(ax[0],
xlabel=r'$t/t_{ff}$',
ylabel=r'$\rho$',
yscale='log',
ylim=[rho_min, rho_max])
ax[1].plot(times, B, c=c, linewidth=0.1)
axbonk(ax[1], xlabel=r'$t/t_{ff}$', ylabel='B', yscale='log')
ax[2].plot(times, np.log10(B) / np.log10(rho), c=c, linewidth=0.1)
ax[2].set_yscale('symlog', linthresh=1)
ax[3].scatter(rho[0, :], B[0, :])
ax[3].scatter(rho[-1, :], B[-1, :])
ax[3].plot(rho, B, c=c, linewidth=0.1)
axbonk(ax[3], xscale='log', yscale='log', xlabel='rho', ylabel='B')
outname = 'plots_to_sort/%s_b_and_rho_t_c%04d.png' % (
this_looper.sim_name, core_id)
fig.savefig(outname)
print(outname)
def simple_rho(this_looper,core_list=None):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr=this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times=thtr.times[mask]+0 #the zero makes a copy
times.shape=times.size,1
times=times/colors.tff
G = colors.G
gx = thtr.track_dict['grav_x']
gy = thtr.track_dict['grav_y']
gz = thtr.track_dict['grav_z']
GE2 = -1/(8*np.pi)*(gx*gx+gy*gy+gz*gz)
ge_min=GE2.min()
ge_max=GE2.max()
for core_id in core_list:
fig,ax=plt.subplots(1,1)
ms = trackage.mini_scrubber(thtr,core_id, do_velocity=False)
#ms.particle_pos(core_id)
if ms.nparticles < 1000:
sl=slice(None)
c=[0.5]*4
else:
sl = slice(None,None,10)
#c=[0,0,0,0.1]
c=[0.1]*4
rho = ms.density[sl].transpose()
rho = rho[mask,:]
gx = thtr.c([core_id],'grav_x')[sl].transpose()[mask,:]
gy = thtr.c([core_id],'grav_y')[sl].transpose()[mask,:]
gz = thtr.c([core_id],'grav_z')[sl].transpose()[mask,:]
GE2 = 1/(8*np.pi*G)*(gx*gx+gy*gy+gz*gz)
ax.plot(times , GE2, c=c, linewidth=0.1)
axbonk(ax,xlabel=r'$t/t_{ff}$', ylabel=r'$(\nabla \phi)^2/8 pi G$',yscale='log', ylim=[ge_min,ge_max])
ax2=ax.twinx()
c=[1.0,0.1,0.1,0.1]
ax2.plot(times , rho, c=c, linewidth=0.1)
axbonk(ax2,xlabel=r'$t/t_{ff}$', ylabel=r'$\rho$',yscale='log')
outname='plots_to_sort/%s_GE_t_c%04d.png'%(this_looper.sim_name,core_id)
fig.savefig(outname)
print(outname)
def vr_vt(this_looper, core_list=None, symlog=False):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr = this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times = thtr.times[mask] + 0 #the zero makes a copy
times = times / colors.tff
vr_extents = extents()
fig, ax = plt.subplots(1, 2, figsize=(12, 8))
axlist = ax.flatten()
for core_id in core_list:
for aaa in axlist:
aaa.clear()
ms = trackage.mini_scrubber(thtr, core_id, do_velocity=True)
vr = ms.vr_rel[:, mask]
vt = np.sqrt(ms.vt2_rel[:, mask])
#r = ms.r[:,mask]
#omega = vt/r
#print(omega.min(),omega.max())
Nlin = 32
Nlog = 32
if symlog:
bins1 = np.geomspace(1, 20, Nlog)
bins2 = np.linspace(-1, 1, Nlin)
bins = np.unique(np.concatenate([-bins1[::-1], bins2, bins1]))
else:
bins = np.linspace(-16, 16, 65)
vvv = [vr, vt]
for nv, v in enumerate(vvv):
label = [r'$v_r$', r'$v_t$', r'$\omega$'][nv]
stuff = heat_map.heat_map(v, times, ax=axlist[nv], bins=bins)
axlist[nv].plot(times, times * 0, c='k')
axlist[nv].plot(times, times * 0 + 1, c='k')
axlist[nv].plot(times, times * 0 - 1, c='k')
axbonk(axlist[nv], xlabel=r'$t/t_{ff}$', ylabel=label)
if symlog:
axlist[nv].set_yscale('symlog', linthresh=1)
outname = '/home/dccollins/PigPen/%s_vr_vt_c%04d.png' % (
this_looper.sim_name, core_id)
fig.savefig(outname)
print(outname)
def div_v_hair(this_looper, core_list=None):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr = this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times = thtr.times[mask] + 0 #the zero makes a copy
times.shape = times.size, 1
times = times / colors.tff
rho_all = thtr.track_dict['density']
rho_min = rho_all.min()
rho_max = rho_all.max()
B_all = thtr.track_dict['magnetic_field_strength']
B_min = B_all.min()
B_max = B_all.max()
fig, ax = plt.subplots(1, 1)
RM = np.zeros([len(times), len(core_list)])
BM = np.zeros([len(times), len(core_list)])
DivV = np.zeros([len(times), len(core_list)])
AllDivV = thtr.track_dict['velocity_divergence']
MinDivV = AllDivV.min()
MaxDivV = AllDivV.max()
for nc, core_id in enumerate(core_list):
ax.clear()
#print("%s %d"%(this_looper.sim_name,core_id))
dv = thtr.c([core_id], 'cell_volume').transpose()[mask, :]
Div = thtr.c([core_id], 'velocity_divergence').transpose()[mask, :]
mean_div = (Div * dv).sum(axis=1) / dv.sum(axis=1)
DivV[:, nc] = mean_div
ax.plot(times, Div, c=[0.5] * 4, linewidth=0.1)
axbonk(ax, xlabel='t', ylabel='DivV') #,xscale='log',yscale='log')
ax.set_yscale('symlog', linthresh=250)
ax.plot(times, times * 0 + 250, c=[0.5] * 4)
ax.plot(times, times * 0 - 250, c=[0.5] * 4)
ax.set_ylim([MinDivV, MaxDivV])
outname = 'plots_to_sort/%s_divv_c%04d.png' % (this_looper.sim_name,
core_id)
fig.savefig(outname)
print(outname)
plt.close('all')
def simple_rho(this_looper, core_list=None):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr = this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times = thtr.times[mask] + 0 #the zero makes a copy
times.shape = times.size, 1
times = times / colors.tff
rho_all = thtr.track_dict['density']
rho_min = rho_all.min()
rho_max = rho_all.max()
for core_id in core_list:
fig, ax = plt.subplots(1, 1)
ms = trackage.mini_scrubber(thtr, core_id, do_velocity=False)
ms.particle_pos(core_id)
if ms.nparticles < 1000:
sl = slice(None)
c = [0.5] * 4
else:
sl = slice(None, None, 10)
#c=[0,0,0,0.1]
c = [0.1] * 4
rho = ms.density[sl].transpose()
rho = rho[mask, :]
ax.plot(times, rho, c=c, linewidth=0.1)
axbonk(ax,
xlabel=r'$t/t_{ff}$',
ylabel=r'$\rho$',
yscale='log',
ylim=[rho_min, rho_max])
outname = 'plots_to_sort/%s_rho_t_c%04d.png' % (this_looper.sim_name,
core_id)
fig.savefig(outname)
print(outname)
def simple_v(this_looper, core_list=None, symlog=False):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr = this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times = thtr.times[mask] + 0 #the zero makes a copy
times.shape = times.size, 1
times = times / colors.tff
vr_extents = extents()
fig, ax = plt.subplots(2, 2, figsize=(12, 12))
fig.subplots_adjust(wspace=0, hspace=0)
ax[0][0].xaxis.tick_top()
ax[0][1].xaxis.tick_top()
ax[0][1].xaxis.set_label_position('top')
ax[0][0].xaxis.set_label_position('top')
ax[1][1].yaxis.tick_right()
ax[0][1].yaxis.tick_right()
ax[1][1].yaxis.set_label_position('right')
ax[0][1].yaxis.set_label_position('right')
for core_id in core_list:
axlist = ax.flatten()
for aaa in axlist:
aaa.clear()
ms = trackage.mini_scrubber(thtr, core_id, do_velocity=True)
ms.particle_pos(core_id)
if ms.nparticles < 1000:
sl = slice(None)
c = [0.5] * 4
else:
sl = slice(None, None, 10)
#c=[0,0,0,0.1]
c = [0.1] * 4
vx = ms.raw_vx[sl].transpose()[mask, :]
vy = ms.raw_vy[sl].transpose()[mask, :]
vz = ms.raw_vz[sl].transpose()[mask, :]
vr = ms.rel_vmag[sl].transpose()[mask, :]
vr_extents(vr)
vvv = [vx, vy, vz, vr]
fig2, ax2 = plt.subplots(1, 1)
for nv, v in enumerate(vvv):
axlist[nv].plot(times, v, c=c, linewidth=0.1)
label = [r'$v_x$', r'$v_y$', r'$v_z$', r'$|(v-\bar{v})|$'][nv]
vext = [-20, 20]
axlist[nv].plot(times, times * 0, c='k', linewidth=0.2)
axlist[nv].plot(times, times * 0 + 1, c='k', linewidth=0.2)
axlist[nv].plot(times, times * 0 - 1, c='k', linewidth=0.2)
axbonk(axlist[nv], xlabel=r'$t/t_{ff}$', ylabel=label, ylim=vext)
if symlog:
axlist[nv].set_yscale('symlog', linthresh=1)
ax2.hist(v[-1, :], histtype='step', label=label)
ax2.legend(loc=0)
logornot = ""
if symlog:
logornot = "_symlog"
fig2.savefig('plots_to_sort/vhist_%s%s.png' %
(this_looper.sim_name, logornot))
outname = 'plots_to_sort/%s_v_t_c%04d.png' % (this_looper.sim_name,
core_id)
fig.savefig(outname)
print(outname)
print("VR extents", vr_extents.minmax)
for nset, superset in enumerate(stuff):
if nset != 1:
continue
core_list = list(superset)
color_dict = colors.make_core_cmap(core_list, cmap='tab20c', seed=-1)
frame_list = set_looper.tr.frames[::10]
set_looper.out_prefix = '%s_full_S%02d' % (this_simname, nset)
else:
core_list = np.unique(set_looper.core_ids)[:2]
frame_list = set_looper.tr.frames[::10]
#frame_list=set_looper.tr.frames #[::10]
if 1:
import movie_frames
reload(movie_frames)
movie_mask = movie_frames.quantized_mask(set_looper)
frame_list = set_looper.tr.frames[movie_mask]
frame_list = frame_list[frame_list > 71]
core_list = [323]
frame_list = frame_list[-1:]
color_dict = colors.make_core_cmap(core_list, cmap='tab20c', seed=-1)
if 1:
set_looper.ds_list = {}
derived = []
#derived=[xtra_energy.add_b_over_rho]
derived = [xtra_energy.add_energies]
mono = core_proj.core_proj_multiple(set_looper,
axis_list=[0],
color_dict=color_dict,
frame_list=frame_list,
def simple_v(this_looper, core_list=None, symlog=False):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr = this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times = thtr.times[mask] + 0 #the zero makes a copy
times = times / colors.tff
vr_extents = extents()
fig, ax = plt.subplots(2, 2, figsize=(12, 12))
fig.subplots_adjust(wspace=0, hspace=0)
ax[0][0].xaxis.tick_top()
ax[0][1].xaxis.tick_top()
ax[0][1].xaxis.set_label_position('top')
ax[0][0].xaxis.set_label_position('top')
ax[1][1].yaxis.tick_right()
ax[0][1].yaxis.tick_right()
ax[1][1].yaxis.set_label_position('right')
ax[0][1].yaxis.set_label_position('right')
for core_id in core_list:
axlist = ax.flatten()
for aaa in axlist:
aaa.clear()
ms = trackage.mini_scrubber(thtr, core_id, do_velocity=True)
vx = ms.raw_vx[:, mask]
vy = ms.raw_vx[:, mask]
vz = ms.raw_vx[:, mask]
vr = ms.rel_vmag[:, mask]
vr_extents(vr)
vvv = [vx, vy, vz, vr]
Nlin = 32
Nlog = 32
if symlog:
bins1 = np.geomspace(1, 16, Nlog)
bins2 = np.linspace(-1, 1, Nlin)
bins = np.unique(np.concatenate([-bins1[::-1], bins2, bins1]))
else:
bins = np.linspace(-16, 16, 65)
#fig2,ax2=plt.subplots(1,1)
#ax2.plot(bins)
#fig2.savefig('/home/dccollins/PigPen/bins.png')
for nv, v in enumerate(vvv):
label = [r'$v_x$', r'$v_y$', r'$v_z$', r'$v_r$'][nv]
stuff = heat_map.heat_map(v, times, ax=axlist[nv], bins=bins)
axlist[nv].plot(times, times * 0, c='k')
axlist[nv].plot(times, times * 0 + 1, c='k')
axlist[nv].plot(times, times * 0 - 1, c='k')
axbonk(axlist[nv], xlabel=r'$t/t_{ff}$', ylabel=label)
if symlog:
axlist[nv].set_yscale('symlog', linthresh=1)
if symlog:
logornot = "_symlog"
else:
logornot = ""
outname = 'plots_to_sort/%s_v_t_heat_c%04d%s.png' % (
this_looper.sim_name, core_id, logornot)
fig.savefig(outname)
print(outname)
print("VR extents", vr_extents.minmax)
reload(time_line)
import movie_frames
if 1:
import three_loopers_u500 as TL5
this_looper = TL5.loops['u503']
if 1:
core_list = [223]
core_list = [76]
full_core_list = np.unique(this_looper.tr.core_ids)
core_list = full_core_list
if 0:
movie_mask = movie_frames.quantized_mask(this_looper)
times = this_looper.tr.times[movie_mask] / colors.tff
frames = this_looper.tr.frames[movie_mask]
if 0:
#hair movie
#fig, ax = plt.subplots(1,1,figsize=(12,8))
fig, ax = plt.subplots(1, 1, figsize=(8, 8))
thing = movie_hair.flow(this_looper)
thing.run(core_list=core_list,
frames='reg',
external_ax=ax,
external_fig=fig)
if 1:
#velocity heat map for each core.
def rho_ke_ge(this_looper, core_list=None):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr = this_looper.tr
frames = movie_frames.quantized_mask(this_looper).flatten()
times = thtr.times[frames] + 0 #the zero makes a copy
times.shape = times.size, 1
times = times / colors.tff
rho_all = thtr.track_dict['density']
rho_min = rho_all.min()
rho_max = rho_all.max()
for core_id in core_list:
if 0:
fig, ax = plt.subplots(3, 1, figsize=(8, 12))
fig.subplots_adjust(hspace=0, wspace=0)
ax0 = ax[0]
ax1 = ax[1]
ax2 = ax[2]
fig, ax = plt.subplots(1, 1)
ms = trackage.mini_scrubber(thtr, core_id, do_velocity=True)
ms.particle_pos(core_id)
if ms.nparticles < 1000:
sl = slice(None)
c = [0.5] * 4
else:
sl = slice(None, None, 10)
#c=[0,0,0,0.1]
c = [0.1] * 4
phi = thtr.c([core_id], 'PotentialField')[sl].transpose()
phi = phi[frames, :]
rho = ms.density[sl].transpose()
rho = rho[frames, :]
vx = ms.raw_vx[sl].transpose()
vx = vx[frames, :]
vy = ms.raw_vy[sl].transpose()
vy = vy[frames, :]
vz = ms.raw_vz[sl].transpose()
vz = vz[frames, :]
v2 = vx**2 + vy**2 + vz**2
ke = 0.5 * v2
ge = 0.5 * phi
ax0 = ax
ax1 = ax
ax2 = ax
ax1 = ax0.twinx()
ax2 = ax1
c0 = [1.0, 0.5, 0.5, 0.5]
ax0.plot(times, rho, c=c0, linewidth=0.1)
axbonk(ax0,
xlabel=r'$t/t_{ff}$',
ylabel=r'$\rho$',
yscale='log',
ylim=[rho_min, rho_max])
c1 = [0.5, 1.0, 0.5, 0.5]
ax1.plot(times, ke, c=c1, linewidth=0.1)
axbonk(ax1, xlabel=r'$t/t_{ff}$', ylabel=r'$KE$', yscale='log')
c2 = [0.5, 0.5, 1.0, 0.5]
ax2.plot(times, np.abs(ge), c=c2, linewidth=0.1)
axbonk(ax2, xlabel=r'$t/t_{ff}$', ylabel=r'$GE$', yscale='log')
outname = 'plots_to_sort/%s_rho_ke_ge_t_c%04d.png' % (
this_looper.sim_name, core_id)
fig.savefig(outname)
print(outname)
def GE_pearson(this_looper, core_list=None):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
name = this_looper.sim_name
thtr = this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times = thtr.times[mask] + 0 #the zero makes a copy
times.shape = times.size, 1
times = times / colors.tff
G = colors.G
#gx = thtr.track_dict['grav_x']
#gy = thtr.track_dict['grav_y']
#gz = thtr.track_dict['grav_z']
#GE2 = -1/(8*np.pi)*(gx*gx+gy*gy+gz*gz)
#ge_min=GE2.min()
#ge_max=GE2.max()
PearsonR = np.zeros([len(core_list), len(times)])
PearsonP = np.zeros([len(core_list), len(times)])
PearsonRho = np.zeros([len(core_list), len(times)])
PeakRho = np.zeros([len(core_list), len(times)])
for nc, core_id in enumerate(core_list):
print('GE pearson %s %d' % (name, core_id))
ms = trackage.mini_scrubber(thtr, core_id, do_velocity=False)
#ms.particle_pos(core_id)
if ms.nparticles < 1000:
sl = slice(None)
c = [0.5] * 4
else:
sl = slice(None, None, 10)
#c=[0,0,0,0.1]
c = [0.1] * 4
rho = ms.density[sl]
rho = rho[:, mask]
PeakRho[nc, :] = rho.max(axis=0)
gx = thtr.c([core_id], 'grav_x')[sl][:, mask]
gy = thtr.c([core_id], 'grav_y')[sl][:, mask]
gz = thtr.c([core_id], 'grav_z')[sl][:, mask]
GE2 = 1 / (8 * np.pi * G) * (gx * gx + gy * gy + gz * gz)
RRR = ms.r[sl][:, mask]
for n in range(GE2.shape[1]):
the_x = np.log(RRR[:, n])
the_y = np.log(GE2[:, n])
#the_y=rho[:,n]
r, p = scipy.stats.pearsonr(the_x, the_y)
PearsonR[nc, n] = r
PearsonP[nc, n] = p
the_y = np.log(rho[:, n])
r, p = scipy.stats.pearsonr(the_x, the_y)
PearsonRho[nc, n] = r
if 0:
fig, ax = plt.subplots(1, 2)
ax[0].plot(times, PearsonR)
#ax[0].boxplot(PearsonR)
#ax[1].boxplot(PearsonRho)
fig.savefig('plots_to_sort/phi_box_%s.png' % name)
return {
'PR': PearsonR,
'PP': PearsonP,
'Prho': PearsonRho,
'T': times,
'PeakRho': PeakRho
}
if 0:
fig, ax = plt.subplots(1, 1)
ax.plot(times, GE2, c=c, linewidth=0.1)
axbonk(ax,
xlabel=r'$t/t_{ff}$',
ylabel=r'$(\nabla \phi)^2/8 pi G$',
yscale='log',
ylim=[ge_min, ge_max])
ax2 = ax.twinx()
c = [1.0, 0.1, 0.1, 0.1]
ax2.plot(times, rho, c=c, linewidth=0.1)
axbonk(ax2, xlabel=r'$t/t_{ff}$', ylabel=r'$\rho$', yscale='log')
outname = 'plots_to_sort/%s_GE_t_c%04d.png' % (this_looper.sim_name,
core_id)
fig.savefig(outname)
print(outname)
def div_v_hair(this_looper, core_list=None):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr = this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times = thtr.times[mask] + 0 #the zero makes a copy
times.shape = times.size, 1
times = times / colors.tff
DivV = np.zeros([len(times), len(core_list)])
for nc, core_id in enumerate(core_list):
dv = thtr.c([core_id], 'cell_volume').transpose()[mask, :]
Div = thtr.c([core_id], 'velocity_divergence').transpose()[mask, :]
mean_div = (Div * dv).sum(axis=1) / dv.sum(axis=1)
DivV[:, nc] = mean_div
fig, ax = plt.subplots(1, 1)
DivVall = thtr.track_dict['velocity_divergence']
DivVall_early = DivVall[:, :50].flatten()
YYY = np.mgrid[0:1:DivVall_early.size * 1j]
print(YYY.size)
ax.plot(sorted(DivVall_early), YYY)
outname = 'plots_to_sort/%s_divv_early_hist.png' % (this_looper.sim_name)
axbonk(ax, xlim=[-1000, 1000])
fig.savefig(outname)
print(outname)
if 0:
fig, ax = plt.subplots(1, 1)
rho_min = RM.min()
rho_max = RM.max()
B_min = BM.min()
B_max = BM.max() / 2
print(B_min, B_max)
for iframe in range(times.size):
ax.clear()
ax.plot(RM[:iframe, :], BM[:iframe, :], c=[0.5] * 4, linewidth=0.1)
axbonk(ax,
xlabel='rho',
ylabel='B',
xscale='log',
yscale='log',
xlim=[rho_min, rho_max],
ylim=[B_min, B_max])
outname = 'plots_to_sort/MeanBvsRho_%s_i%04d.png' % (
this_looper.sim_name, iframe)
fig.savefig(outname)
print(outname)
if 0:
fig, ax = plt.subplots(1, 1)
ax.plot(times, RM, c=[1, 0.5, 0.5, 0.5], linewidth=0.1)
ax.plot(times, BM, c=[0.5, 1.0, 0.5, 0.5], linewidth=0.1)
ax.plot(times, np.abs(DivV), c=[0.5, 0.5, 1.0, 0.5], linewidth=0.1)
#ax.plot(times,BM/RM,c=[0.5,0.5,1.0,0.5],linewidth=0.1)
X = nar([times.flatten()] * BM.shape[1]).transpose().flatten()
Y = np.log((BM / RM).flatten())
pfit = np.polyfit(X, np.exp(Y), 1)
ax.set_title('log10 B/Rho = B0 e^(%.1f t)' % (pfit[0]))
#print(pfit)
#ax.clear()
#ax.scatter(X,10**Y)
ax.plot(times, times * pfit[0] + pfit[1], c='k')
#ax.plot(times,RM/BM**2,c=[0.5,0.5,1.0,0.5],linewidth=0.1)
outname = 'plots_to_sort/b_and_rho_%s.png' % (this_looper.sim_name)
axbonk(ax, xlabel='t/tff', ylabel='B,rho', yscale='log')
fig.savefig(outname)
print(outname)
def run(self, core_list=None, symlog=False, do_plots=False, atool=None):
this_looper = self.this_looper
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr = this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times = thtr.times[mask] + 0 #the zero makes a copy
times.shape = times.size, 1
times = times / colors.tff
vr_extents = extents()
if do_plots:
fig, ax = plt.subplots(2, 2, figsize=(12, 12))
axlist = ax.flatten()
fig.subplots_adjust(wspace=0, hspace=0)
ax[0][0].xaxis.tick_top()
ax[0][1].xaxis.tick_top()
ax[0][1].xaxis.set_label_position('top')
ax[0][0].xaxis.set_label_position('top')
ax[1][1].yaxis.tick_right()
ax[0][1].yaxis.tick_right()
ax[1][1].yaxis.set_label_position('right')
ax[0][1].yaxis.set_label_position('right')
ax5 = ax[0][0].twinx()
self.sigma_3d = np.zeros([len(core_list), len(times)])
for nc, core_id in enumerate(core_list):
ms = trackage.mini_scrubber(thtr, core_id, do_velocity=True)
if do_plots:
for aaa in ax.flatten():
aaa.clear()
ax5.clear()
if ms.nparticles < 1000:
sl = slice(None)
c = [0.5] * 4
else:
sl = slice(None, None, 10)
#c=[0,0,0,0.1]
c = [0.1] * 4
#ms.particle_pos(core_id)
ms.get_central_at_once(core_id)
vx = ms.rel_vx[sl].transpose()[mask, :]
vy = ms.rel_vy[sl].transpose()[mask, :]
vz = ms.rel_vz[sl].transpose()[mask, :]
vr = ms.rel_vmag[sl].transpose()[mask, :]
vr_extents(vr)
vvv = [vx, vy, vz, vr]
if do_plots:
for nv, v in enumerate(vvv):
axlist[nv].plot(times, v, c=c, linewidth=0.1)
label = [r'$v_x$', r'$v_y$', r'$v_z$',
r'$|(v-\bar{v})|$'][nv]
vext = [-20, 20]
axlist[nv].plot(times, times * 0, c='k', linewidth=0.2)
axlist[nv].plot(times, times * 0 + 1, c='k', linewidth=0.2)
axlist[nv].plot(times, times * 0 - 1, c='k', linewidth=0.2)
axbonk(axlist[nv],
xlabel=r'$t/t_{ff}$',
ylabel=label,
ylim=vext)
if symlog:
axlist[nv].set_yscale('symlog', linthresh=1)
axlist[3].set_ylim([0, vext[1]])
if atool is not None:
ax5.plot(times,
atool.Alpha_rho_r[nc, :],
c='r',
label=r'$\alpha$')
ax5.plot(times,
atool.Pearson_rho_r[nc, :],
c='g',
label=r'$r-\rho$')
ax5.plot(times,
atool.Pearson_GE_r[nc, :],
c='b',
label=r'$r-GE$')
ax5.set_ylim(-2.5, 2.5)
ax5.legend(loc=2)
logornot = ""
if symlog:
logornot = "_symlog"
outname = 'plots_to_sort/%s_v_t_c%04d.png' % (
this_looper.sim_name, core_id)
fig.savefig(outname)
print(outname)
def simple_rho(this_looper, core_list=None):
if core_list is None:
core_list = np.unique(this_looper.tr.core_ids)
thtr = this_looper.tr
mask = movie_frames.quantized_mask(this_looper).flatten()
times = thtr.times[mask] + 0 #the zero makes a copy
times.shape = times.size, 1
times = times / colors.tff
rho_all = thtr.track_dict['density']
rho_min = rho_all.min()
rho_max = rho_all.max()
B_all = thtr.track_dict['magnetic_field_strength']
B_min = B_all.min()
B_max = B_all.max()
fig, ax = plt.subplots(1, 1)
RM = np.zeros([len(times), len(core_list)])
BM = np.zeros([len(times), len(core_list)])
DivV = np.zeros([len(times), len(core_list)])
for nc, core_id in enumerate(core_list):
#print("%s %d"%(this_looper.sim_name,core_id))
rho = thtr.c([core_id], 'density').transpose()[mask, :]
dv = thtr.c([core_id], 'cell_volume').transpose()[mask, :]
B = thtr.c([core_id], 'magnetic_field_strength').transpose()[
mask, :] / colors.mean_field[this_looper.sim_name]
rho_mean = (rho * dv).sum(axis=1) / dv.sum(axis=1)
RM[:, nc] = rho_mean
B_mean = (B * dv).sum(axis=1) / dv.sum(axis=1)
BM[:, nc] = B_mean
Div = thtr.c([core_id], 'velocity_divergence').transpose()[mask, :]
mean_div = (Div * dv).sum(axis=1) / dv.sum(axis=1)
DivV[:, nc] = mean_div
ax.plot(rho_mean, B_mean, c=[0.5] * 4, linewidth=0.1)
axbonk(ax, xlabel='rho', ylabel='B', xscale='log', yscale='log')
outname = 'plots_to_sort/%s_mean_b_and_rho.png' % (this_looper.sim_name)
fig.savefig(outname)
print(outname)
plt.close('all')
if 0:
fig, ax = plt.subplots(1, 1)
rho_min = RM.min()
rho_max = RM.max()
B_min = BM.min()
B_max = BM.max() / 2
print(B_min, B_max)
for iframe in range(times.size):
ax.clear()
ax.plot(RM[:iframe, :], BM[:iframe, :], c=[0.5] * 4, linewidth=0.1)
axbonk(ax,
xlabel='rho',
ylabel='B',
xscale='log',
yscale='log',
xlim=[rho_min, rho_max],
ylim=[B_min, B_max])
outname = 'plots_to_sort/MeanBvsRho_%s_i%04d.png' % (
this_looper.sim_name, iframe)
fig.savefig(outname)
print(outname)
if 1:
fig, ax = plt.subplots(1, 1)
ax.plot(times, RM, c=[1, 0.5, 0.5, 0.5], linewidth=0.1)
ax.plot(times, BM, c=[0.5, 1.0, 0.5, 0.5], linewidth=0.1)
#ax.plot(times,np.abs(DivV),c=[0.5,0.5,1.0,0.5],linewidth=0.1)
ax.plot(times, BM / RM, c=[0.5, 0.5, 1.0, 0.5], linewidth=0.1)
if 1:
X = nar([times.flatten()] * BM.shape[1]).transpose().flatten()
Y = np.log((BM / RM).flatten())
pfit = np.polyfit(X, np.exp(Y), 1)
ax.set_title('log10 B/Rho = B0 e^(%.1f t)' % (pfit[0]))
#print(pfit)
#ax.clear()
#ax.scatter(X,10**Y)
ax.plot(times, times * pfit[0] + pfit[1], c='k')
if 0:
X = nar([times.flatten()] * BM.shape[1]).transpose().flatten()
Y = np.log((BM / RM).flatten())
pfit = np.polyfit(X, Y, 1)
ax.set_title('log10 B/Rho = B0 e^(%.1f t)' % (pfit[0]))
print(pfit)
#ax.clear()
#ax.scatter(X,10**Y)
ax.plot(times, np.exp(times * pfit[0] + pfit[1]), c='k')
#ax.plot(times,RM/BM**2,c=[0.5,0.5,1.0,0.5],linewidth=0.1)
outname = 'plots_to_sort/b_and_rho_%s.png' % (this_looper.sim_name)
axbonk(ax, xlabel='t/tff', ylabel='B,rho', yscale='log')
fig.savefig(outname)
print(outname)