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)