def plot_many_spectra(self,ts,prefix,fname='TEST.png', **kwargs):
def dostuff(arr):
return np.abs(arr[1:])#/np.abs(arr[2]) #np.abs((arr/arr[2])[1:])
fig,ax=plt.subplots(1,1)
k = ts['vspec'][0]
ylimits=dt.extents()
xlim=dt.extents()
pos_k=slice(None)
#this_k=(k/k[1])[pos_k]
this_k=(k*2*np.pi)#[1:]
this_k = 0.5*(this_k[1:]+this_k[:-1])
ax.plot( this_k,dostuff(ts['aspec'][1][pos_k]),marker='*', label=r'$P(a)$'); ylimits(ts['aspec'][1][pos_k])# print('a lim',ylimits)
ax.plot( this_k,dostuff(ts['vspec'][1][pos_k]),marker='*', label=r'$P(v)$'); ylimits(ts['vspec'][1][pos_k])# print('v lim',ylimits)
ax.plot( this_k,dostuff(ts['dspec'][1][pos_k]),marker='*', label=r'$P(\rho)$');ylimits(ts['dspec'][1][pos_k])# print('d lim',ylimits)
ax.plot( this_k,dostuff(ts['hspec'][1][pos_k]),marker='*', label=r'$P(H)$'); ylimits(ts['hspec'][1][pos_k])# print('h lim',ylimits)
ell=ts['lcent']
#this_ell=(ell/ell[1])[pos_k]
this_ell=ell[:-1]#[1:]
ax.plot( this_ell,dostuff(ts['ClEE'][pos_k]),marker='*', label=r'$C_{\ell}^{EE}$'); ylimits(ts['ClEE'])# print(ylimits)
ax.plot( this_ell,dostuff(ts['ClBB'][pos_k]),marker='*', label=r'$C_{\ell}^{BB}$'); ylimits(ts['ClBB'])# print(ylimits)
ax.plot( this_ell,dostuff(ts['ClTE'][pos_k]),marker='*', label=r'$ClTE$') ; ylimits(ts['ClTE'])# print(ylimits)
ax.plot( this_ell,dostuff(ts['ClTT'][pos_k]),marker='*', label=r'$ClTT$') ; ylimits(ts['ClTT'])# print(ylimits)
ax.plot( this_ell,dostuff(ts['ClHH'][pos_k]),marker='*', label=r'$ClHH$') ; ylimits(ts['ClHH'])# print(ylimits)
ax.plot( this_ell,dostuff(ts['ClTB'][pos_k]),marker='*', label=r'$ClTB$') ; ylimits(ts['ClTB'])# print(ylimits)
ax.plot( this_ell,dostuff(ts['ClEB'][pos_k]),marker='*', label=r'$ClEB$') ; ylimits(ts['ClEB'])# print(ylimits)
dt.powerline(ax, this_ell[1]*2, this_ell[1]*30, 1, -5./3,c='k',label='-5/3')
dt.powerline(ax, this_ell[1]*2, this_ell[1]*30, 1, -2.5,c='k',label='-2.5',linestyle='--')
#ax.plot( this_ell, np.abs(ts['pork'])[pos_k],marker='*', label=r'pork') ; ylimits(ts['ClTE']); print(ylimits)
#ts['ColumnDensity']= np.abs(cmbtools.harm2cl( ts['Eh'], ts['Deltal'],ts['lbins']))
#ax.plot(this_ell,np.abs(ts['ColumnDensity'][pos_k]),c='k')
#ax.plot( ell/ell[1], ts['ClTB'],marker='*', label=r'$ClEB$')
xlim(this_k)
xlim(this_ell)
ax.legend(loc=1)
ts.limits=ylimits
#dt.axbonk(ax,xlabel='k/k1',ylabel='power',xscale='log',yscale='log')
dt.axbonk(ax,xlabel='k/k1',ylabel='power',xscale='log',yscale='log')
#ax.set_xscale('symlog',linthreshx=1)
#ax.set_xlim(xlim)
#ax.set_ylim(1e-9,1e4)
#ax.set_yscale('symlog',linthreshy=1e-28)
#ax.set_ylim(ylimits)
ax.set_ylim(1e-7,50)
print("ylimits",ylimits)
title="%s n%04d %s"%(prefix,ts['frame'],ts['axis'])
print("POOT",title)
ax.set_title(title)
fig.savefig(fname)
plt.close(fig)
def __init__(self,this_looper):
self.this_looper=this_looper
self.rho_extents=davetools.extents()
self.r_extents=davetools.extents()
self.alpha = []
self.mass = []
self.density_0=[]
self.mean_div = []
self.alpha_dict={}
self.ft_lst_rho0=[]
self.ft_lst_r0=[]
self.ft_lst_alpha=[]
self.mini_alphas={}
self.collapse_times=[]
self.cores_used=[]
def plot_eb(self,ts,fname='TEST.png', slopes=None):
"""plot spectra extracted from e&b.
the function 'dostuff' treats normalization and slicing."""
def dostuff(arr):
return arr[1:]#/np.abs(arr[2]) #np.abs((arr/arr[2])[1:])
def dostuff2(arr):
return arr[1:]#/np.abs(arr[2]) #np.abs((arr/arr[2])[1:])
fig,ax=plt.subplots(1,1)
k = ts.vspec[0]
ylimits=dt.extents()
xlim=dt.extents()
pos_k=slice(None)
this_k=(k/k[1])[pos_k]
this_k=(k*2*np.pi)#[1:]
this_k = 0.5*(this_k[1:]+this_k[:-1])
ell=ts.lcent
#this_ell=(ell/ell[1])[pos_k]
this_ell=ell[:-1]#[1:]
rEB = ts['ClEB']/(ts['ClEE']*ts['ClBB'])**0.5
lab=r'$r_{EB}=C_{\ell}^{EB}/\sqrt{C_{\ell}^{EE}C_{\ell}^{EE}}$'
ax.plot( this_k,dostuff2(ts['aspec'][1]),c='k',marker='*', label=r'$a$'); ylimits(ts['aspec'][1][pos_k])# print('a lim',ylimits)
ax.plot( this_ell,dostuff2(ts['ClEE']), marker='*', label=r'$EE$',c='g'); ylimits(rEB)# print(ylimits)
if slopes is not None:
slopes.plot(ax,'EE',label=r'$\alpha^{EE}$',c='r')
ax.plot( this_ell,dostuff2(ts['ClBB']), marker='*', label=r'$BB$',c='b'); ylimits(rEB)# print(ylimits)
ax.plot( this_ell,dostuff(rEB), marker='*', label=r'$r_{EB}$',c='m'); ylimits(rEB)# print(ylimits)
dt.axbonk(ax,xlabel='k/k1',ylabel=lab,xscale='log',yscale='log')
#ax.set_xscale('symlog',linthreshx=1)
#ax.set_xlim(xlim)
#ax.set_ylim(1e-9,1e4)
#ax.set_ylim(ylimits)
ax.set_yscale('symlog',linthreshy=1e-2)
ax.set_ylim(-30,30)
#print("ylimits",ylimits)
title="%s n%04d %s"%(self.prefix,ts['frame'],ts['axis'])
ax.legend(loc=0)
ax.set_title(title)
fig.savefig(fname)
print("saved "+fname)
plt.close(fig)
def plot_2eb(self,ts0,ts1,slopes0=None,slopes1=None,fname='TEST.png', slopes=None):
"""plot spectra extracted from e&b.
the function 'dostuff' treats normalization and slicing."""
def dostuff(arr):
return arr[1:]#/np.abs(arr[2]) #np.abs((arr/arr[2])[1:])
def dostuff2(arr):
return arr[1:]#/np.abs(arr[2]) #np.abs((arr/arr[2])[1:])
fig,axes=plt.subplots(1,2)
ax0 = axes[0]; ax1 = axes[1]
for ns,ts in enumerate([ts0,ts1]):
slopes = [slopes0,slopes1][ns] #this is clunky, sorry.
ax=axes[ns]
ylimits=dt.extents()
xlim=dt.extents()
ell=ts.lcent
this_ell=ell[:-1]#[1:]
lab=r'$C_\ell^{EE}$'
ax.plot( this_ell,dostuff2(ts['ClEE']), marker='*', label=r'$EE$',c='g')
#the slope value is added to the label in slopes.plot
if slopes is not None:
slopes.plot(ax,'EE',label=r'$\alpha^{EE}$',c='r',norm=1)#ts.bin_style=='5deg')
#ax.plot( this_ell,dostuff2(ts['ClBB']), marker='*', label=r'$BB$',c='b')
dt.axbonk(ax,xlabel='k/k1',ylabel=lab,xscale='log',yscale='log')
ax.set_yscale('symlog',linthreshy=1e-10)
#ax.set_yscale('log')
ax.set_ylim(0,0.5e-3)
ax.set_xlim(0.01,2*np.pi)
#ax.set_ylim(0,1e-3)
title=["new binning","old binning"][ns]
ax.legend(loc=0)
ax.set_title(title)
fig.savefig(fname)
print("saved "+fname)
plt.close(fig)
vel_rel_x = []
vel_rel_y = []
vel_rel_z = []
v_mag_rel = []
x_rel = []
y_rel = []
z_rel = []
R_rel = []
n_x = []
n_y = []
n_z = []
Vel_rad = []
if 0:
if 'rho_extents' not in dir():
rho_extents = davetools.extents()
r_extents = davetools.extents()
for nc, core_id in enumerate(all_cores):
ms = trackage.mini_scrubber(thtr, core_id)
if ms.nparticles == 1:
continue
density = thtr.c([core_id], 'density')
rho_extents(density)
r_extents(ms.r)
for nc, core_id in enumerate(core_list):
plt.clf()
print("why")
density_all = []
radius_all = []
log_density = []
class alpha_tool():
def __init__(self,this_looper):
self.this_looper=this_looper
self.rho_extents=davetools.extents()
self.r_extents=davetools.extents()
self.alpha = []
self.mass = []
self.density_0=[]
self.mean_div = []
self.alpha_dict={}
self.ft_lst_rho0=[]
self.ft_lst_r0=[]
self.ft_lst_alpha=[]
self.mini_alphas={}
self.collapse_times=[]
self.cores_used=[]
def run(self, core_list=None, do_all_plots=False):
thtr = self.this_looper.tr
all_cores = np.unique(thtr.core_ids)
if core_list is None:
core_list=all_cores
rm = rainbow_map(len(all_cores))
if len(self.rho_extents.minmax) == 0:
for nc,core_id in enumerate(all_cores):
ms = trackage.mini_scrubber(thtr,core_id)
if ms.nparticles == 1:
continue
density = thtr.c([core_id],'density')
self.rho_extents(density)
self.r_extents(ms.r)
self.r_extents.minmax[0]=0.5/2048
asort = np.argsort(thtr.times)
if (asort != sorted(asort)).any():
print("Warning: times not sorted.")
for nc,core_id in enumerate(core_list):
#miniscrubber computes distance, r^2, several other quantities
ms = trackage.mini_scrubber(thtr,core_id)
if ms.nparticles < 3:
continue
self.cores_used.append(core_id)
density = thtr.c([core_id],'density')
if 1:
#collapse time
if (density>1e3).any():
first_collapse_index = np.where( (density>1e3).sum(axis=0) >0 )[0][0]
t_collapse = thtr.times[first_collapse_index]
self.collapse_times.append(t_collapse)
else:
t_collapse = -1
self.collapse_times.append(t_collapse)
#Compute alpha
#compute mean initial density.
this_r = ms.r.flatten()
min_r = 1./2048
this_r[ this_r < min_r ] = min_r
fit = scatter_fit.scatter_fit(plt,this_r,density.flatten())
self.alpha.append(fit['fit'][0])
self.alpha_dict[core_id]=self.alpha[-1]
self.density_0.append( density[:,0].mean()) #this is not good
this_rho = density.flatten()
popt, pcov = curve_fit(powerlaw, this_r, np.log10(this_rho), p0=[1,1,-2])
fit_rho0, fit_r0, fit_alpha = popt
self.ft_lst_rho0.append(fit_rho0)
self.ft_lst_r0.append(fit_r0)
self.ft_lst_alpha.append(fit_alpha)
#compute initial mass.
for nf in [0]:
dx=1./2048
nx=2048
x =np.floor(thtr.c([core_id],'x')/dx)[:,nf]
y =np.floor(thtr.c([core_id],'y')/dx)[:,nf]
z =np.floor(thtr.c([core_id],'z')/dx)[:,nf]
this_density = density[:,nf]
cell_volume = thtr.c([core_id],'cell_volume')[:,nf]
index = x + nx*(y * nx*z)
ar = np.argsort(index)
rs = np.argsort(ar)
isorted=index[ar]
mask = np.ones_like(this_density,dtype='bool')
mask[1:] = isorted[1:]-isorted[:-1] != 0
mask2 = mask[ rs]
self.mass.append((this_density[mask2]*cell_volume[mask2]).sum())
if do_all_plots:
fig, axes=plt.subplots(1,2)
axd1 = axes[0]; axd2 = axes[1]
#other_fit = other_fit(this_r, density.flatten())
this_r = np.array([min_r, 0.3])
#this_r[ this_r < min_r] = min_r
axd1.plot( this_r, 10**powerlaw(this_r, popt[0],popt[1],popt[2]))
#axd1.plot( this_r, 0.1*(this_r/0.3)**alpha[-1],c='k')
#axd1.plot( this_r, 0.1*(this_r/0.3)**-0.5,c=[0.9]*3)
#axd1.plot( this_r, 0.1*(this_r/0.3)**-1.0,c=[0.9]*3)
#axd1.plot( this_r, 0.1*(this_r/0.3)**-1.5,c=[0.9]*3)
#axd1.plot( this_r, 0.1*(this_r/0.3)**-2.0,c=[0.9]*3)
#axd1.plot( this_r, 0.1*(this_r/0.3)**-2.5,c=[0.9]*3)
tmap=rainbow_map(ms.ntimes)
self.mini_alphas[core_id]=[]
time_list_dumb=[]
color_list_dumb=[]
for n_count,n_time in enumerate(asort):
time=thtr.times[n_time]
if time == 0:
continue
c=tmap(n_count,ms.nparticles)
time_list_dumb.append(time)
color_list_dumb.append(c[0])
this_r=ms.r[:,n_time]+0
this_r[ this_r < min_r] = min_r
this_density=density[:,n_time]
#popt, pcov = curve_fit(powerlaw, this_r, np.log10(this_density), p0=[1,1,-2])
lilfit=np.polyfit( np.log10(this_r), np.log10(this_density), 1)
axd1.scatter(this_r,this_density,c=c,label=thtr.times[n_time],s=0.1)
axd1.plot( this_r, 10**(lilfit[0]*np.log10(this_r)+lilfit[1]),c=c[0])
self.mini_alphas[core_id].append(lilfit[0])
title=""
title+=r'$\alpha = %0.3f\ \rho_0 = $%s$ r_0=$%s'%(self.alpha[-1], expform(fit_rho0),expform(fit_r0))
axd1.set_title(title)
axbonk(axd1,xscale='log',yscale='log',xlabel='r',ylabel=r'$\rho$',
xlim=self.r_extents.minmax, ylim=self.rho_extents.minmax)
axd1.set_ylim(self.rho_extents.minmax)
axd1.set_xlim(self.r_extents.minmax)
axd2.scatter(time_list_dumb, self.mini_alphas[core_id],c=color_list_dumb)
axd2.plot(time_list_dumb, self.mini_alphas[core_id],c=[0.5]*3)
#axd2.plot(time_list_dumb, [fit_alpha]*len(time_list_dumb),c='k')
axd2.plot(time_list_dumb, [-1]*len(time_list_dumb), c=[0.5]*4)
axd2.plot(time_list_dumb, [-0.5]*len(time_list_dumb),c=[0.5]*4)
axd2.plot(time_list_dumb, [-1.5]*len(time_list_dumb),c=[0.5]*4)
axd2.plot(time_list_dumb, [-2]*len(time_list_dumb), c=[0.5]*4)
axbonk(axd2,xlabel=r'$t$',ylabel=r'$\alpha(t)$',ylim=[-4,2])
#axbonk(axd2,xscale='log',yscale='log',xlabel='r',ylabel=r'$\rho$',
# xlim=r_extents.minmax, ylim=rho_extents.minmax)
outname = '%s/%s_density_radius_c%04d'%(dl.output_directory,self.this_looper.out_prefix,core_id)
fig.savefig(outname)
print("saved "+outname)
plt.close(fig)
def do_plots(self):
mass=nar(self.mass)
sim_color={'u05':'r','u10':'g','u11':'b'}[self.this_looper.out_prefix]
fig, axes=plt.subplots(2,2)
ax0 = axes[0][0]; ax1=axes[0][1]
ax2 = axes[1][0]; ax3=axes[1][1]
ax0.scatter(self.density_0,self.alpha,c=sim_color)
ax1.scatter(mass,self.alpha,c=sim_color)
fig2, axes2=plt.subplots(1,1)
bx0 = axes2
if 'collapse_times' in dir(): #collapse_time can be found from density_time.py
ok = nar(collapse_times) > 0
t_ok=nar(collapse_times)[ok]
ax2.scatter(t_ok, nar(self.alpha)[ok])
ax3.scatter(t_ok, nar(self.mass)[ok],c=nar(sim_color)[ok])
bx0.scatter(t_ok, nar(self.density_0)[ok])
#ax3.scatter(t_ok, nar(density_0)[ok],c=nar(sim_color)[ok])
pdb.set_trace()
davetools.axbonk(ax0,xlabel=r'$\langle \rho \rangle$',ylabel=r'$\alpha$', xscale='log',yscale='linear')
davetools.axbonk(ax1,xlabel=r'$M(t=0)$', ylabel=r'$\alpha$', xscale='log',yscale='linear')
davetools.axbonk(ax2,xlabel=r'$t_c$', ylabel=r'$\alpha$', xscale='log',yscale='linear')
davetools.axbonk(ax3,xlabel=r'$t_c$', ylabel=r'$M(t=0)$', xscale='log',yscale='log')
davetools.axbonk(bx0,xlabel=r'$t_c$', ylabel=r'$\langle \rho \rangle$', xscale='log',yscale='linear')
ax3.set_xlim([t_ok.min(),t_ok.max()])
ax3.set_ylim(self.mass.min(),self.mass.max())
ax1.set_xlim(self.mass.min(),self.mass.max())
outname = '%s/alpha_mass.png'%dl.output_directory
fig.savefig(outname)
outname2 = '%s/tc_rho.png'%dl.output_directory
fig2.savefig(outname2)
print(outname)
if 0:
mass=nar(mass)
fig, axes=plt.subplots(2,2)
ax0 = axes[0][0]; ax1=axes[0][1]
ax2 = axes[1][0]; ax3=axes[1][1]
ax0.scatter(density_0,alpha)
ax1.scatter(mass,alpha)
#ax2.scatter(total_volume,alpha)
#ax3.scatter(total_volume,mass)
davetools.axbonk(ax0,ylabel=r'$\alpha$', xlabel=r'$\langle \rho \rangle$', xscale='log',yscale='linear')
davetools.axbonk(ax1,ylabel=r'$\alpha$', xlabel=r'$M(t=0)$', xscale='log',yscale='linear')
#vol_lim=[min(total_volume),max(total_volume)]
mass_lim=[min(mass),max(mass)]
davetools.axbonk(ax2,ylabel=r'$\alpha$', xlabel=r'$V(t=0)$', xscale='log',yscale='linear',xlim=vol_lim)
davetools.axbonk(ax3,ylabel=r'$M(t=0)$', xlabel=r'$V(t=0)$', xscale='log',yscale='log',xlim=vol_lim,ylim=mass_lim)
ax1.set_xlim(mass.min(),mass.max())
outname = '%s/alpha_mass.png'%dl.output_directory
fig.savefig(outname)
print(outname)
#plt.clf()
#alpha=np.array(alpha)
#ft_lst_alpha=np.array(ft_lst_alpha)
#plt.scatter(alpha,1-(alpha/ft_lst_alpha))
#plt.savefig('plots_to_sort/alpha_alpha.png')
#plt.close('all')
#fig,ax=plt.subplots(1,1)
#ax.scatter(ft_lst_rho0,ft_lst_r0)
#axbonk(ax,xlabel=r'$\rho_0$',ylabel=r'$r_0$',xscale='log',yscale='log')
#fig.savefig('plots_to_sort/rho0_r0.png')
if 'alpha_proxy' not in dir() and False:
do_all_plots=True
div_v=[]
v_over_r=[]
divv_extents=davetools.extents()
divv_extents( thtr.track_dict['velocity_divergence'])
proxy_extents=davetools.extents()
for nc,core_id in enumerate(core_list):
#miniscrubber computes distance, r^2, several other quantities
ms = trackage.mini_scrubber(thtr,core_id)
if ms.nparticles == 1:
continue
density = thtr.c([core_id],'density')
div_v = thtr.c([core_id],'velocity_divergence')
mag_v = thtr.c([core_id],'velocity_magnitude')
divv_extents(div_v)
if do_all_plots:
tmap=rainbow_map(ms.ntimes)
fig, axes=plt.subplots(2,2)
ax00=axes[0][0]; ax01=axes[0][1]
ax10=axes[1][0]; ax11=axes[1][1]
for n_count,n_time in enumerate(asort):
time=thtr.times[n_time]
if time == 0:
continue
c=tmap(n_count,ms.nparticles)
this_r=ms.r[:,n_time]+0
ax00.scatter(this_r,div_v[:,n_time],c=c,label=thtr.times[n_time],s=0.1)
ax01.scatter(this_r,mag_v[:,n_time],c=c,label=thtr.times[n_time],s=0.1)
alpha_proxy = div_v[:,n_time]/mag_v[:,n_time]*ms.r[:,n_time]
proxy_extents(alpha_proxy)
ax10.scatter(this_r,alpha_proxy.flatten(),c=c,label=thtr.times[n_time],s=0.1)
davetools.axbonk(ax00,xscale='log',yscale='linear',xlabel='r',ylabel=r'$\nabla\cdot v$',
xlim=r_extents.minmax, ylim=rho_extents.minmax)
ax00.set_yscale('symlog',linthreshy=1)
ax00.set_ylim(-5e5,5e5)
davetools.axbonk(ax01,xscale='log',yscale='log',xlabel='r',ylabel=r'$|v|$',
xlim=r_extents.minmax, ylim=rho_extents.minmax)
ax01.set_yscale('symlog',linthreshy=1)
ax01.set_ylim(0,100)
ax10.plot([1e-3,1e-1], [alpha_dict[core_id],alpha_dict[core_id]],c='k')
ax10.plot([1e-3,1e-1], [-0.5,-0.5],c=[0.5]*4)
ax10.plot([1e-3,1e-1], [-3,-3],c=[0.5]*4)
davetools.axbonk(ax10,xscale='log',yscale='linear',xlabel='r',ylabel=r'$\nabla\cdot v/(v/r)$',
xlim=r_extents.minmax, ylim=rho_extents.minmax)
ax10.set_yscale('symlog',linthreshy=0.1)
ax10.set_ylim(proxy_extents.minmax)
outname = '%s/divergence_proxy_c%04d'%(dl.output_directory,core_id)
fig.savefig(outname)
print("saved "+outname)
plt.close(fig)
if 'this_looper' not in dir():
this_looper = looper.core_looper(directory=dl.enzo_directory)
for nfile, fname in enumerate(file_list):
this_looper.load_loop(fname)
print("Reading file %s %d of %d" % (fname, nfile, len(file_list)))
thtr = this_looper.tr
thtr.sort_time()
all_cores = np.unique(thtr.core_ids)
core_list = all_cores
rm = rainbow_map(len(all_cores))
if 1:
if 'all_extents' not in dir():
print("rerun grav extents")
all_extents = davetools.extents()
r_extents = davetools.extents()
for nc, core_id in enumerate(all_cores):
ms = trackage.mini_scrubber(thtr, core_id)
if ms.nparticles == 1:
continue
grav_energy = thtr.c([core_id], 'grav_energy')
all_extents(grav_energy)
r_extents(ms.r)
if 1:
r_min = 0.5 / 2048 #
r_max = r_extents.minmax[1] * (1.00001)
r_bins = np.linspace(0, r_max, 64)
#r_bins = np.logspace(np.log(r_min),np.log(r_max),100)
'/home/dcollins/scratch/Paper19/particle_error/particle_error_test_c0031_threeframes.h5'
)
file_list = glob.glob(
'/home/dcollins/scratch/Paper19/particle_error/track_indfix_sixteenframe_core_0031.h5'
)
file_list = glob.glob(
'/home/dcollins/scratch/Paper19/particle_error/track_indfix_sixteenframe_core_0031.h5'
)
file_list = glob.glob(
'/scratch1/dcollins/Paper19/track_index_fix/track_indfix_sixteenframe_core_*.h5'
)
file_list = glob.glob(
'/home/dcollins/scratch/Paper19/track_index_fix/track_indfix_sixteenframe_core_*.h5'
)
if 'ext_v' not in dir():
ext_v = DT.extents()
ext_r = DT.extents()
print("Running Extents")
for nfile, fname in enumerate(file_list):
this_looper = looper.core_looper(directory=directory)
trw.load_loop(this_looper, fname)
if True:
for frame in this_looper.snaps:
for core_id in this_looper.snaps[frame]:
snap = this_looper.snaps[frame][core_id]
if snap.R_mag.size > 1:
ext_v(snap.V_radial)
ext_r(snap.R_mag)
nvel_bins = 10
nrad_bins = 20
#file_list=file_list[:3]
if 'this_looper' not in dir():
this_looper=looper.core_looper(directory=dl.enzo_directory)
for nfile,fname in enumerate(file_list):
this_looper.load_loop(fname)
print( "Reading file %d of %d"%(nfile,len(file_list)))
thtr = this_looper.tr
thtr.sort_time()
all_cores = np.unique(thtr.core_ids)
core_list=all_cores
rm = rainbow_map(len(all_cores))
if 'rho_extents' not in dir():
rho_extents=davetools.extents()
field_extents=davetools.extents()
r_extents=davetools.extents()
for nc,core_id in enumerate(all_cores):
ms = trackage.mini_scrubber(thtr,core_id)
if ms.nparticles == 1:
continue
density = thtr.c([core_id],'density')
field = thtr.c([core_id],'magnetic_field_strength')
field_extents(field)
rho_extents(density)
r_extents(ms.r)
theta_extents=davetools.extents()
alphab_list=[]
for nc,core_id in enumerate(core_list):
def run(self, core_list=None):
dx = 1. / 2048
nx = 1. / dx
thtr = self.this_looper.tr
all_cores = np.unique(thtr.core_ids)
if core_list is None:
core_list = all_cores
thtr.sort_time()
if self.rho_extents is None:
self.rho_extents = davetools.extents()
self.r_extents = davetools.extents()
for nc, core_id in enumerate(all_cores):
ms = trackage.mini_scrubber(thtr, core_id)
if ms.nparticles < 20:
continue
density = thtr.c([core_id], 'density')[:, 0]
self.rho_extents(density)
self.r_extents(ms.r)
tsorted = thtr.times
self.core_list = core_list
fig, axd = plt.subplots(2, 2)
axd1 = axd[0][0]
axd2 = axd[0][1] #sorry
axd3 = axd[1][0]
axd4 = axd[1][1]
ds = self.this_looper.load(0)
ad = ds.all_data()
axd2.hist(np.log10(ad['density'].v.flatten()),
histtype='step',
color='k')
rmcore = rainbow_map(len(core_list))
for nc, core_id in enumerate(core_list):
ms = trackage.mini_scrubber(thtr, core_id)
self.ms = ms
if ms.nparticles < 10:
continue
self.cores_used.append(core_id)
tmap = rainbow_map(ms.ntimes)
asort = np.argsort(thtr.times)
density = thtr.c([core_id], 'density')
n0 = asort[0]
tsorted = thtr.times[asort]
#fig, axd1=plt.subplots(1,1)
for n_count, n_time in enumerate(asort[0:1]):
mask2 = ms.compute_unique_mask(core_id,
dx=1. / 2048,
frame=n_count)
time = thtr.times[n_time]
c = tmap(n_count, mask2.sum())
c = rmcore(nc, mask2.sum())
this_r = ms.r[:, n_time] + 0
r_un = nar(sorted(np.unique(this_r)))
axd1.scatter(this_r[mask2],
density[mask2, n_time],
c=c,
label=thtr.times[n_time],
s=0.1)
axd2.hist(np.log10(density[mask2, n_time]),
histtype='step',
color=c[0])
axd1.plot(r_un, 100 * (r_un / 1e-2)**-2, c='k', linewidth=0.1)
axd3.scatter(density[mask2, n_time].mean(),
density[mask2, n_time].std())
davetools.axbonk(axd1,
xscale='log',
yscale='log',
xlabel='r',
ylabel=r'$\rho$',
xlim=self.r_extents.minmax,
ylim=self.rho_extents.minmax)
davetools.axbonk(axd2,
xscale='linear',
yscale='log',
xlabel='r',
ylabel=r'$\rho$',
xlim=np.log10(self.rho_extents.minmax))
#outname = '%s/density_radius_c%04d'%(dl.output_directory,core_id)
outname = '%s/density_radius_n0000.png' % (dl.output_directory)
fig.savefig(outname)
print("saved " + outname)
plt.close(fig)
this_field_z[i],
c='k',
marker='*',
alpha=0.4)
#axplts[i].scatter(this_rho[i],the_zz[i],c='g',alpha=0.2)
# IF PLOTTING THE POWER LAW, we can comment this out
#magfield_density_tool.labelled(axplts[i],xscale='log',yscale='log',xlabel=r'$\rho$',ylabel=r'$Bz$',\
# title=None, xlim=xlims,ylim=ylims)
#outname_frame='Scatter_LogBzvsRho_%s_%d'%(simnames[nt],i)
#figs[i].savefig(outname_frame)
#print("saved")
if 0: #for all extents I should combine these next ones with the extents in main definition
#maybe include under the next switch
rho_extents = davetools.extents()
rho_extents(the_a)
magfield_extents = davetools.extents()
magfield_extents(the_b)
magfieldz_extents = davetools.extents()
magfieldz_extents(the_c)
if 0: # FOR ONE FRAME PER TIME; MULTIPLE PANEL ..in progress: I think it will be best if I end up moving this to the next if statement.
tmap2 = rainbow_map(len(this_rho))
c2 = [tmap2(n) for n in range(len(this_rho))]
for i in range(len(this_rho)):
if i in frames:
lplots[i].scatter(
this_rho[i], this_field[i], c=c2[i], marker='*'
) #C2 gives me lots of notes, but it works...
#lplots[n_time].plot(xx2,yy,c='k',linewidth=1.0) #SEE BELOW
# GLOBAL TFF
G = 1620/(4*np.pi)
rho_mean = 1
t_ff = np.sqrt(3*np.pi/(32*G*rho_mean))
# TFF PERCENTAGE:
tff_p = thtr.times[:2]/t_ff #MUST be editted for suitable time steps
tff_labels = ['%.2f'%s for s in tff_p]
# - - - - - - - - - - - - - - - - - - - -
rm = rainbow_map(len(all_cores))
if 'rho_extents' not in dir():
rho_extents=davetools.extents()
magfield_extents = davetools.extents()
vorticity_extents = davetools.extents() #ADDED
r_extents=davetools.extents()
for nc,core_id in enumerate(all_cores):
ms = trackage.mini_scrubber(thtr,core_id)
if ms.nparticles == 1:
continue
density = thtr.c([core_id],'density')
zeroes = density[0][0]
if zeroes == 0:
print(':------(',location)
magfield = thtr.c([core_id],'magnetic_field_strength')
magfield_x = thtr.c([core_id],'magnetic_field_z') #ADDED
rho_extents(density)
def run(self,name,thtr,timing,typeplot,
fig=None,ax1=None,ax2=None,ax3=None,ax4=None,ax5=None,ax7=None,ax8=None,
lplots=None,core_list=None,simframes=None):
def pearsonR(the_x, the_y):
# LOGGED
# NOTE: the "else" statements are a holder for the pearsonR's that are nans;
# these need to be accounted for rightfully. suggestion: reverse the time,core loops
xs = np.std(the_x)
ys = np.std(the_y)
# SCIPY PEARSONr:
if xs != 0 and ys != 0:
pearX,pearY = scipy.stats.pearsonr(the_x,the_y)
else:
print("A zero encountered!!",xs,ys)
#print("core id and sim ",core_id,name) #EXP
#self.corestdzero = np.append(self.corestdzero,core_id) #EXP
pearX = 0 # try a break from the current loop...which would only be of the time, not core...
self.pearsonr = np.append(self.pearsonr,pearX)
def scatterplots(fig=None,ax1=None,ax2=None,ax3=None,ax4=None,ax5=None,ax7=None,ax8=None,
lplots=None,xx2=None,yy=None):
if typeplot == 'scatter_plot':
ax1.scatter(density[:,n_time],magfield[:,n_time],c=c,label=thtr.times[n_time],s=0.1) #edit thtr.times
ax1.plot(xx2,yy,c='k',linewidth=1.0) #c=c[0] for colors
BRho_tool.labelled(ax1,xscale='log',yscale='log',xlabel=r'$\rho/\rho_{o}$',ylabel=r'$\mid B \mid (\mu G)$',
xlim=rho_extents.minmax, ylim=magfield_extents.minmax,title=r'$\alpha_{b\rho} = %.3f$'%beta)
if n_time == asort[-1]:
outname = 'brhotff_all_c%04d_%s'%(core_id,name)
plt.savefig(outname) # CAREFUL WITH FIG VS PLT
print("saved "+outname)
plt.close(fig)
if typeplot == 'frame_scatters':
if n_time in simframes:
lplots[n_time].scatter(density[:,n_time],magfield[:,n_time],c=c,label=thtr.times[n_time],s=0.1) #edit thtr.times
lplots[n_time].plot(xx2,yy,c='k',linewidth=1.0) #c=c[0] for colors
print("scatters plotted")
#print('nTIME',n_time)
BRho_tool.labelled(lplots[n_time],xscale='log',yscale='log',xlabel=None,ylabel=None,
xlim=rho_extents.minmax, ylim=magfield_extents.minmax)
ax2.tick_params(axis='y',labelleft=False)
ax4.set_ylabel(r'$\mid B \mid (\mu G)$')
ax5.tick_params(axis='y',labelleft=False)
ax8.tick_params(axis='y',labelleft=False)
if n_time == asort[-1]:
tmap2 = rainbow_map(len(self.betarr))
c2 = [tmap2(n) for n in range(len(self.betarr))]
if name == 'u201':
tmap2 = rainbow_map(len(self.betarr[2:]))
c2 = [tmap2(n) for n in range(len(self.betarr[2:]))]
the_range = np.arange(0,1,0.075)
ax3.scatter(the_range,self.betarr[2:],c=c2)
ax3.plot(the_range,self.betarr[2:],c='k',linewidth=1.0)
ax3.set_title(r"$\beta = 0.2, \alpha_{B}$")
if name == 'u202':
the_range = np.arange(0.075,1,0.075)
ax3.scatter(the_range,self.betarr,c=c2)
ax3.plot(the_range,self.betarr,c='k',linewidth=1.0)
ax3.set_title(r"$\beta = 2.0, \alpha_{B}$")
if name == 'u203':
the_range = np.arange(0.075,0.9,0.075)
ax3.scatter(the_range,self.betarr,c=c2)
ax3.plot(the_range,self.betarr,c='k',linewidth=1.0)
ax3.set_title(r"$\beta = 20, \alpha_{B}$")
ax3.plot([0,1],[0,0],c=[0.5]*4)
ax3.plot([0,1],[0.4,0.4],'--',c=[0.5]*4)
tff_mod = [0.0,0.0,0.3,0.6,0.9] #this should match multiplelocator
ax3.set_xticklabels(tff_mod)
ax3.xaxis.set_major_locator(plt.MultipleLocator(0.3))
ax3.yaxis.tick_right()
ax3.set_xlabel(r'$t_{\rm{ff}}$') #\rm{ },to avoid italization
ax3.set_yscale('linear')
ax3.set_ylim(-0.5,0.5)
self.betarr = np.empty([0],dtype=float)
outname = 'brhotff_c%04d_%s'%(core_id,name)
plt.savefig(outname) # CAREFUL WITH FIG VS PLT
print("saved "+outname)
plt.close(fig) #CAREFUL, this doesn't allow to do another desired core :(
if typeplot == 'box_plot' and n_time == asort[-1]:
self.bear0 = np.append(self.bear0,self.betarr[0])
self.bear1 = np.append(self.bear1,self.betarr[1])
self.bear2 = np.append(self.bear2,self.betarr[2])
self.bear3 = np.append(self.bear3,self.betarr[3])
self.bear4 = np.append(self.bear4,self.betarr[4])
self.bear5 = np.append(self.bear5,self.betarr[5])
self.bear6 = np.append(self.bear6,self.betarr[6])
self.bear7 = np.append(self.bear7,self.betarr[7])
self.bear8 = np.append(self.bear8,self.betarr[8])
self.bear9 = np.append(self.bear9,self.betarr[9])
self.bear10 = np.append(self.bear10,self.betarr[10])
self.bear11 = np.append(self.bear11,self.betarr[11])
if name == 'u201':
self.bear12 = np.append(self.bear12,self.betarr[12])
self.bear13 = np.append(self.bear13,self.betarr[13])
#self.bear14 = np.append(self.bear14,self.betarr[14])
self.bears = [self.bear0,self.bear1,self.bear2,self.bear3,self.bear4,self.bear5,self.bear6,\
self.bear7,self.bear8,self.bear9,self.bear10,self.bear11,self.bear12,self.bear13]#,self.bear14]
self.betarr = np.empty([0],dtype=float)
if typeplot == 'vio_plot' and n_time == asort[-1]:
#print('NTIME_in',n_time)
self.pear0 = np.append(self.pear0,self.pearsonr[0])
self.pear1 = np.append(self.pear1,self.pearsonr[1])
self.pear2 = np.append(self.pear2,self.pearsonr[2])
self.pear3 = np.append(self.pear3,self.pearsonr[3])
self.pear4 = np.append(self.pear4,self.pearsonr[4])
self.pear5 = np.append(self.pear5,self.pearsonr[5])
self.pear6 = np.append(self.pear6,self.pearsonr[6])
self.pear7 = np.append(self.pear7,self.pearsonr[7])
self.pear8 = np.append(self.pear8,self.pearsonr[8])
self.pear9 = np.append(self.pear9,self.pearsonr[9])
self.pear10 = np.append(self.pear10,self.pearsonr[10])
self.pear11 = np.append(self.pear11,self.pearsonr[11]) #final u203 pear contains nans
if name == 'u201':
self.pear12 = np.append(self.pear12,self.pearsonr[12]) #final u202 pear, but want to discard final frame
self.pear13 = np.append(self.pear13,self.pearsonr[13])
self.pear14 = np.append(self.pear14,self.pearsonr[14])
self.pears = [self.pear0,self.pear1,self.pear2,self.pear3,self.pear4,self.pear5,self.pear6,\
self.pear7,self.pear8,self.pear9,self.pear10,self.pear11,self.pear12,self.pear13,self.pear14]
self.pearsonr = np.empty([0],dtype=float)
# - - - - - - - - - - - - - - - - - - - -
# CONTINUE RUN DEFINITION
all_cores = np.unique(thtr.core_ids)
if core_list is None:
#core_list = all_cores # OR
# CAREFUL, check looper.py if chosing this option! particles > 10
core_list = looper.get_all_nonzero(dl.n_particles[name])
#rm = rainbow_map(len(core_list)) # or all_cores, needed??
rho_extents=davetools.extents()
magfield_extents = davetools.extents()
# - - - - - - - - - - - - - - - - - - - -
# CORELOOP
for nc,core_id in enumerate(core_list):
# THIS DISCARDS THE FAULTY CORES OF THE SIMS: does this still hold with new density CUTS?
if name == 'u201':
if core_id == 166:
continue
if core_id == 34:
continue
if core_id == 14:
continue
if name == 'u202':
if core_id == 269:
continue
if core_id == 211:
continue
ms = trackage.mini_scrubber(thtr,core_id,do_velocity=False)
tmap=rainbow_map(ms.ntimes)
# FIELDS
density = thtr.c([core_id],'density')
magfield = thtr.c([core_id],'magnetic_field_strength')
cv = thtr.c([core_id],'cell_volume')
if name != 'u201':
#print("name",name)
B_x = thtr.c([core_id],'magnetic_field_x')
B_y = thtr.c([core_id],'magnetic_field_y')
B_z = thtr.c([core_id],'magnetic_field_z')
v_x = thtr.c([core_id],'velocity_x')
v_y = thtr.c([core_id],'velocity_y')
v_z = thtr.c([core_id],'velocity_z')
rho_extents(density)
magfield_extents(magfield)
asort = np.argsort(thtr.times)
if (asort != sorted(asort)).any():
print("Warning: times not sorted.")
# SETUP FIGURES FOR EACH CORE HERE:
if which_plot == 'scatter_plot' or 'rms_plot':
fig, ax1=plt.subplots(1,1)
# - - - - - - - - - - - - - - - - - - - -
# TIMELOOP:
for n_count,n_time in enumerate(asort):
#print("in the TIME loop")
mask = ms.compute_unique_mask(core_id, dx=1./2048,frame=n_time)
c=tmap(n_count,mask.sum()) #Used to be: ms.nparticles
if timing == 'per_frame':
X = np.log10(density[mask,n_time]).flatten() # [mask,n_time], OR [:,n_time][mask]
Y = np.log10(magfield[mask,n_time]).flatten()
if timing == 'all_time':
time=thtr.times[n_time]
if time == 0:
continue
X = np.log10(density).flatten() # unsure how to account for all time with 'mask'
Y = np.log10(magfield).flatten()
if timing == 'all_time':
X2 = np.linspace(X.min()+2,X.max()-3,num=len(X)) # FOR ALL TIME, ONE PANEL PLOTS
if timing == 'per_frame':
X2 = np.linspace(X.min(),X.max(),num=len(X)) # FOR PER FRAME, MULTIPLE PANEL PLOTS
XX2 = 10 ** X2
# POLY-FITTING:
pfit = np.polyfit(X,Y,1)
other = np.poly1d(pfit)
beta = pfit[0]
B_o = pfit[1]
YY = 10 ** (pfit[0]*X2 + pfit[1])
if timing == 'all_time':
if n_time == asort[-1]:
self.betarr = np.append(self.betarr,beta)
else:
self.betarr = np.append(self.betarr,beta)
# THE NEGATIVE OUTLIERS
if beta < 0:
self.time_stamp = np.append(self.time_stamp,n_time)
# CALL PEARSON R
if typeplot == 'vio_plot':
pearsonR(X,Y)
if n_time == asort[-1]:
scatterplots()
break #TEMPORARY FIX to get violin plots :-/
# CALL SCATTER
if typeplot == 'frame_scatters' or 'scatter_plot':
scatterplots(fig,ax1,ax2,ax3,ax4,ax5,ax7,ax8,lplots,XX2,YY)
# RMS EXPERIMENTS
if typeplot == 'rms_plot':
if name != 'u201':
B_avg = (magfield[mask,n_time] * cv[mask,n_time]).sum()/cv[mask,n_time].sum()
Bx_avg = (B_x[mask,n_time] * cv[mask,n_time]).sum()/cv[mask,n_time].sum()
By_avg = (B_y[mask,n_time] * cv[mask,n_time]).sum()/cv[mask,n_time].sum()
Bz_avg = (B_z[mask,n_time] * cv[mask,n_time]).sum()/cv[mask,n_time].sum()
vx_avg = (v_x[mask,n_time] * cv[mask,n_time]).sum()/cv[mask,n_time].sum()
vy_avg = (v_y[mask,n_time] * cv[mask,n_time]).sum()/cv[mask,n_time].sum()
vz_avg = (v_z[mask,n_time] * cv[mask,n_time]).sum()/cv[mask,n_time].sum()
Bx_sq = (B_x[mask,n_time] - Bx_avg)**2
By_sq = (B_y[mask,n_time] - By_avg)**2
Bz_sq = (B_z[mask,n_time] - Bz_avg)**2
vx_sq = (v_x[mask,n_time] - Bx_avg)**2
vy_sq = (v_y[mask,n_time] - By_avg)**2
vz_sq = (v_z[mask,n_time] - Bz_avg)**2
# SPREAD OF B FIELD FROM THE MEAN, also the standard dev...these should give same-sh as np.std()?
brms = np.sqrt(np.mean(Bx_sq) + np.mean(By_sq) + np.mean(Bz_sq)) # DO MEAN WITH CV !
brms_py = np.std(magfield) #COMPARE for fun, but for the vector field
#print('BRMS',brms)
#print('BRMS_py',brms_py)
vrms = np.sqrt(np.mean(vx_sq) + np.mean(vy_sq) + np.mean(vz_sq)) # DO MEAN WITH CV!!
#vrms_py = np.std() #COMPARE for fun, VELOCITY mag.
vrmsq_bmean = (vrms**2)/B_avg #B_avg for all box or region; try diff ways
#print('VRMS',vrms)
#print('VRMS_py',vrms_py)
self.brms = np.append(self.brms,brms)
self.vrms = np.append(self.vrms,vrms)
self.vrmsq_bmean = np.append(self.vrmsq_bmean,vrmsq_bmean)
if n_time == asort[-1]:
print('vrmsq_bmean',self.vrmsq_bmean)
#breakpoint()
print('inside!')
tmap2 = rainbow_map(len(self.brms))
c2 = [tmap2(n) for n in range(len(self.brms))]
if name == 'u202':
the_range = np.arange(0.075,1,0.075)
#ax1.scatter(the_range,self.brms,c='b')
#ax1.scatter(the_range,self.vrms,c='g')
#ax1.scatter(self.vrms, self.brms,c=c2)
ax1.scatter(self.vrmsq_bmean, self.brms,c=c2)
#ax1.set_xscale('log')
#ax1.set_yscale('log')
#ax1.set_title(r"$\beta = 2.0$, B_rms: blue, V_rms: green, core:%04d"%core_id)
ax1.set_title(r"$\beta = 2.0$, B_rms vs V_rms vs tff, core:%04d"%core_id)
outname = 'Brms_vrmsqBm_tff_c%04d_%s'%(core_id,name)
plt.savefig(outname) # CAREFUL WITH FIG VS PLT
print("saved "+outname)
#plt.close(fig) #CAREFUL, this doesn't allow to do another desired core :(
if name == 'u203':
the_range = np.arange(0.075,0.9,0.075)
#ax1.scatter(the_range,self.brms,c='b')
#ax1.scatter(the_range,self.vrms,c='g')
#ax1.scatter(self.vrms, self.brms,c=c2)
ax1.scatter(self.vrmsq_bmean, self.brms,c=c2)
#ax1.set_xscale('log')
#ax1.set_yscale('log')
#ax1.set_title(r"$\beta = 20.$, B_rms: blue, V_rms: green, core:%04d"%core_id)
ax1.set_title(r"$\beta = 20.$, B_rms vs V_rms vs tff, core:%04d"%core_id)
outname = 'Brms_vrmsqBm_tff_c%04d_%s'%(core_id,name)
plt.savefig(outname) # CAREFUL WITH FIG VS PLT
print("saved "+outname)
#plt.close(fig) #CAREFUL, this doesn't allow to do another desired core :(
self.vrmsq_bmean = np.empty([0],dtype=float)
self.brms = np.empty([0],dtype=float)
self.vrms = np.empty([0],dtype=float)
def run(self,core_list=None):
dx=1./2048
nx = 1./dx
thtr = self.this_looper.tr
all_cores = np.unique(thtr.core_ids)
if core_list is None:
core_list = all_cores
thtr.sort_time()
if self.rho_extents is None:
self.rho_extents=davetools.extents()
self.r_extents=davetools.extents()
for nc,core_id in enumerate(all_cores):
ms = trackage.mini_scrubber(thtr,core_id)
if ms.nparticles < 20:
continue
density = thtr.c([core_id],'density')
self.rho_extents(density)
self.r_extents(ms.r)
tsorted = thtr.times
self.core_list=core_list
ds= self.this_looper.load(0)
ad = ds.all_data()
rmcore=rainbow_map(len(core_list))
for nc,core_id in enumerate(core_list):
ms = trackage.mini_scrubber(thtr,core_id)
self.ms = ms
if ms.nparticles < 10:
continue
self.cores_used.append(core_id)
fig, axd=plt.subplots(2,2)
axd1 = axd[0][0]; axd2=axd[0][1]#sorry
axd3 = axd[1][0]; axd4=axd[1][1]
tmap=rainbow_map(ms.ntimes)
asort = np.argsort(thtr.times)
density = thtr.c([core_id],'density')
n0=asort[0]
tsorted = thtr.times[asort]
gx = thtr.c([core_id],'grav_x')
gy = thtr.c([core_id],'grav_y')
gz = thtr.c([core_id],'grav_z')
grav = 1/(8*np.pi)*(gx*gx+gy*gy+gz*gz)
grav = np.abs(thtr.c([core_id],'PotentialField'))
#fig, axd1=plt.subplots(1,1)
for n_count,n_time in enumerate(asort):
mask2 = ms.compute_unique_mask(core_id, dx=1./2048,frame=n_count)
mask2[:]=True
time=thtr.times[n_time]
c=tmap(n_count,mask2.sum())
#c=rmcore(nc, mask2.sum())
this_r=ms.r[:,n_time]+0
this_r[ this_r<1/2048]=1/2048
r_un = nar(sorted(np.unique(this_r)))
mask2 = mask2 * (this_r > 0)
axd1.scatter(this_r[mask2],density[mask2,n_time],c=c,label=thtr.times[n_time],s=0.1)
axd2.hist(np.log10(density[mask2,n_time]), histtype='step',color=c[0])
axd3.scatter( this_r[mask2], grav[mask2, n_time], c=c,s=0.1)
the_x = np.log(this_r[mask2]); the_y=np.log(density[mask2,n_time])
r,p=scipy.stats.pearsonr(the_x,the_y)
axd4.scatter( thtr.times[n_time], r, c=tmap(n_count,1))
the_x = np.log(this_r[mask2]); the_y=np.log(grav[mask2,n_time])
r,p=scipy.stats.pearsonr(the_x,the_y)
axd4.scatter( thtr.times[n_time], r, c=tmap(n_count,1),marker='*')
davetools.axbonk(axd1,xscale='log',yscale='log',xlabel='r',ylabel=r'$\rho$',
xlim=[1/2048,self.r_extents.minmax[1]], ylim=self.rho_extents.minmax)
davetools.axbonk(axd2,xscale='linear',yscale='log',xlabel='r',ylabel=r'$\rho$',
xlim=np.log10(self.rho_extents.minmax))
axbonk(axd3,xscale='log',yscale='log',xlabel='r',ylabel='GE')
outname = '%s/density_radius_c%04d.png'%(dl.output_directory,core_id)
#outname = '%s/density_radius_n0000.png'%(dl.output_directory)
fig.savefig(outname)
print("saved "+outname)
plt.close(fig)
def run(self, core_list=None):
thtr = self.this_looper.tr
all_cores = np.unique(thtr.core_ids)
if core_list is None:
core_list = all_cores
thtr.sort_time()
rm = rainbow_map(len(all_cores))
if self.rho_extents is None:
self.rho_extents = davetools.extents()
self.r_extents = davetools.extents()
for nc, core_id in enumerate(all_cores):
ms = trackage.mini_scrubber(thtr, core_id)
if ms.nparticles == 1:
continue
density = thtr.c([core_id], 'density')
self.rho_extents(density)
self.r_extents(ms.r)
plt.close('all')
fig, axd1 = plt.subplots(1, 1)
fig4, ax4 = plt.subplots(2, 2)
ax40 = ax4[0][0]
ax41 = ax4[0][1]
ax42 = ax4[1][0]
ax43 = ax4[1][1]
if self.vel_ext is None:
#If we haven't done it yet, we'll need to run the velocity extents.
self.vel_ext = extents()
print("doing velocity extents")
for nc, core_id in enumerate(core_list):
ms = trackage.mini_scrubber(thtr, core_id, do_velocity=True)
sigma2 = np.sqrt(
(ms.rel_vx**2 + ms.rel_vy**2 + ms.rel_vx**2).mean(axis=0))
self.vel_ext(sigma2)
self.vel_ext(ms.rel_vx)
self.vel_ext(ms.rel_vy)
self.vel_ext(ms.rel_vz)
self.vel_ext(ms.rel_vmag)
print('make plots')
for nc, core_id in enumerate(core_list):
#miniscrubber computes distance, r^2, several other quantities
ms = trackage.mini_scrubber(thtr, core_id, do_velocity=True)
for ax in [axd1, ax40, ax41, ax42, ax43]:
ax.clear()
tmap = rainbow_map(ms.ntimes)
if ms.nparticles == 1:
continue
asort = np.argsort(thtr.times)
density = thtr.c([core_id], 'density')
if (asort != sorted(asort)).any():
print("Warning: times not sorted.")
n0 = asort[0]
tsorted = thtr.times[asort]
if ms.nparticles < 100:
this_slice = slice(None)
else:
this_slice = slice(None, None, 10)
for npart in list(range(ms.nparticles))[this_slice]:
ax40.set_title("%s particles" % ms.nparticles)
this_r = ms.r[npart, :] + 0
this_r[this_r < 1. / 2048] = 1. / 2048
r_un = nar(sorted(np.unique(this_r)))
this_t = thtr.times
c = [0.5] * 3
outname4 = '%s/%s_vi_t_rel_volume_centroid_c%04d' % (
dl.output_directory, self.this_looper.out_prefix, core_id)
ax40.plot(this_t, ms.rel_vx[npart, :], c=c, lw=.1)
ax41.plot(this_t, ms.rel_vy[npart, :], c=c, lw=.1)
ax42.plot(this_t, ms.rel_vz[npart, :], c=c, lw=.1)
ax43.plot(this_t, ms.rel_vmag[npart, :], c=c, lw=.1)
mean_vmag = np.mean(ms.rel_vmag, axis=0)
sigma2 = np.sqrt(
(ms.rel_vx**2 + ms.rel_vy**2 + ms.rel_vx**2).mean(axis=0))
ax43.plot(this_t, mean_vmag, c='r')
ax43.plot(this_t, sigma2, 'r:')
unique_mask = ms.compute_unique_mask(core_id, dx=1. / 2048)
um = unique_mask
mean_vmag = np.mean(ms.rel_vmag[um], axis=0)
sigma2 = np.sqrt((ms.rel_vx[um]**2 + ms.rel_vy[um]**2 +
ms.rel_vx[um]**2).mean(axis=0))
ax43.plot(this_t, mean_vmag, c='g')
ax43.plot(this_t, sigma2, 'g:')
ax43.plot(this_t, np.mean(np.abs(ms.vr_rel), axis=0), c='b')
#axd1.plot([ms.r.min(),ms.r.max()], [1,1], c=[0.5]*4)
limits = np.abs(self.vel_ext.minmax).max()
limits = [-limits, limits]
labs = ['vx', 'vy', 'vz', 'vtotal']
for iii, ax4i in enumerate([ax40, ax41, ax42, ax43]):
davetools.axbonk(ax4i,
xlabel='r',
ylabel=labs[iii],
xscale='linear',
ylim=limits)
ax4i.set_yscale('symlog', linthresh=2)
#ax4i.set_yscale('linear')
ax43.set_ylim([0, limits[1]])
if 0:
davetools.axbonk(axd1,
xscale='linear',
yscale='linear',
xlabel='vr_rel',
ylabel=r'$v_r/v_{total}$')
#xlim=[-15,15], ylim=[0,15])
outname = '%s/ratio_c%04d' % (dl.output_directory, core_id)
if 0:
davetools.axbonk(axd1,
xscale='linear',
yscale='linear',
xlabel='vr_rel',
ylabel=r'$rel_v2$',
xlim=[-15, 15],
ylim=[0, 15])
outname = '%s/vr_vtotal_c%04d' % (dl.output_directory, core_id)
if 0:
davetools.axbonk(axd1,
xscale='log',
yscale='log',
xlabel='r',
ylabel=r'$v$',
xlim=r_extents.minmax,
ylim=rho_extents.minmax)
axd1.set_xscale('symlog', linthresh=1. / 2048)
axd1.set_xlim([0, 1])
axd1.set_yscale('symlog', linthresh=1.)
axd1.set_ylim([0, 15])
outname = '%s/vr_vtotal_c%04d' % (dl.output_directory, core_id)
#outname = '%s/vr_vtotal_c%04d'%(dl.output_directory,core_id)
#fig.savefig(outname)
#print("saved "+outname)
fig4.savefig(outname4)
print("saved " + outname4)
plt.close(fig4)
