def sdf_getdata(sdf_file): try: sdf_handle = sdf.read(sdf_file) except Exception as err: print("Warning: Unreadable sdf file {}".format(sdf_file)) return((np.nan,np.nan,np.nan)) try: ey = getattr(sdf_handle, "Electric_Field_Ey").data x = getattr(sdf_handle, "Grid_Grid").data[0] eyargmax = np.unravel_index(np.argmax(ey), ey.shape)[0] eymax = np.max(ey) xmax = x[eyargmax] try: las_lambda = get_lambda(x, ey) except Exception as e: print(type(e)) print(e) las_lambda = np.nan except Exception as e: print(e) print("Warning: Missing field data in {}".format(sdf_file)) return((np.nan,np.nan,np.nan,np.nan)) if xmax == 0: return((np.nan,np.nan,np.nan,np.nan)) try: bmax = np.max(getattr(sdf_handle, "Particles_Px_electron").data / getattr(sdf_handle, "Particles_Gamma_electron").data) bmax = bmax / (sc.m_e * sc.c) except Exception as err: bmax = np.nan return((xmax,eymax,bmax, las_lambda))
def __init__(self, sdffile, **kwargs): super(self.__class__, self).__init__(sdffile, **kwargs) import os.path import sdf try: sdfversion = sdf.__version__ except(AttributeError): sdfversion = '0.0.0' if sdfversion < '2.2.0': raise ImportError('Upgrade sdf package to 2.2.0 or higher.') if not os.path.isfile(sdffile): raise IOError('File "' + str(sdffile) + '" doesnt exist.') self._data = sdf.read(sdffile, dict=True)
def get_time(time=0, wkd=None): global data, wkdir if wkd is not None: wkdir = wkd flist = glob.glob(wkdir + "/[0-9]*.sdf") if len(flist) == 0: flist = glob.glob("./[0-9]*.sdf") if len(flist) == 0: print("No SDF files found") return wkdir = '.' t = None t_old = -1 jobid = None fname = None for f in sorted(flist): dat_tmp = sdf.read(f) jobid_tmp = dat_tmp.Header['jobid1'] if jobid is None: jobid = jobid_tmp elif jobid != jobid_tmp: continue t = dat_tmp.Header['time'] if time is None: if t > t_old: fname = f t_old = t else: if t >= time - 1e-30: fname = f break if fname is None: raise Exception("No valid file found in directory: " + wkdir) data = getdata(fname, verbose=False) return data
def read(*args, **kwargs): """Reads an SDF file and returns a dictionary of NumPy arrays containing the file data.""" data = sdf.read(*args, **kwargs) sdfdict = {} for key, value in data.__dict__.items(): if hasattr(value, "name"): if hasattr(value, "data"): sdfdict[value.name] = value.data else: sdfdict[value.name] = value else: if hasattr(value, "data"): sdfdict[key] = value.data else: sdfdict[key] = value # Add separate grid variables t = type(value) if t == sdf.BlockPlainMesh or t == sdf.BlockPointMesh \ or t == sdf.BlockLagrangianMesh: base = value.name if value.id == "grid": base += "_node" elif value.id == "grid_mid": base = base[:-4] for n in range(len(value.dims)): newkey = base + '/' + value.labels[n] sdfdict[newkey] = value.data[n] # Add material block if t == sdf.BlockStitchedMaterial: sdfdict["Materials"] = value.material_names return sdfdict
import sys import sdf import matplotlib.pyplot as plt fname = sys.argv[1] radius = float(sys.argv[2]) varname = "Fluid_Energy" try: d = sdf.read(fname) except: print 'File "%s" not found' % fname sys.exit() # print d.__dict__ if not hasattr(d, varname): print 'Variable "%s" not found in file' % varname sys.exit() var = d.__dict__[varname] x = var.grid.data[0][:-1] y = var.grid.data[1][:-1] for i, slice1 in enumerate(var.data): for j, slice2 in enumerate(slice1): for k, val in enumerate(slice2): if (x[i]**2 + y[j]**2) < radius: print val
def getdata(fname, wkd=None, verbose=True): global data, t, step, p, ppi, ppe, rho, ei, ee, vx, vy, vz, bx, by, bz global x, y, z, xc, yc, zc, grid, grid_mid global old_mtime, old_filename, old_size, cached global wkdir if wkd is not None: wkdir = wkd if isinstance(fname, int): filename = wkdir + "/%0.4i.sdf" % fname else: filename = fname try: st = os.stat(filename) except OSError as e: filename = "./%0.4i.sdf" % fname try: st = os.stat(filename) wkdir = '.' except OSError as e: print("ERROR opening file {0}: {1}".format(filename, e.strerror)) raise if st.st_mtime != old_mtime or st.st_size != old_size \ or filename != old_filename: if verbose: print("Reading file " + filename) data = sdf.read(filename) old_mtime = st.st_mtime old_size = st.st_size old_filename = filename else: cached = True return data cached = False fdict = {} sdfdict = {} for key, value in data.__dict__.items(): if hasattr(value, "id"): sdfdict[value.id] = value else: sdfdict[key] = value table = {'time': 't'} k = 'Header' if k in sdfdict: h = sdfdict[k] k = list(table.keys())[0] if k in h: key = table[k] var = h[k] if verbose: print(key + str(np.shape(var)) + ' = ' + k) fdict[key] = var globals()[key] = var builtins.__dict__[key] = var table = {'Pressure': 'p', 'Pressure_ion': 'ppi', 'Pressure_electron': 'ppe', 'Rho': 'rho', 'Energy_ion': 'ei', 'Energy_electron': 'ee', 'Vx': 'vx', 'Vy': 'vy', 'Vz': 'vz', 'Vr': 'vx', 'VTheta': 'vz', 'Bx': 'bx', 'By': 'by', 'Bz': 'bz', 'Br': 'bx', 'Bt': 'bz', 'bx': 'bx', 'by': 'by', 'bz': 'bz', 'ex': 'ex', 'ey': 'ey', 'ez': 'ez', 'jx': 'jx', 'jy': 'jy', 'jz': 'jz'} rz = False if 'Vr' in sdfdict: rz = True if rz: table['Vz'] = 'vy' table['Bz'] = 'by' inv_table = {} for k, v in table.items(): inv_table[v] = inv_table.get(v, []) inv_table[v].append(k) for k in table: if k in sdfdict: key = table[k] if hasattr(sdfdict[k], "data"): var = sdfdict[k].data else: var = sdfdict[k] dims = str(tuple(int(i) for i in sdfdict[k].dims)) if verbose: print(key + dims + ' = ' + k) fdict[key] = var globals()[key] = var builtins.__dict__[key] = var k = 'grid' if k in sdfdict: vargrid = sdfdict[k] grid = vargrid keys = 'x', 'y', 'z' for n in range(np.size(vargrid.dims)): key = keys[n] var = vargrid.data[n] dims = str(tuple(int(i) for i in sdfdict[k].dims)) if verbose: print(key + dims + ' = ' + k) fdict[key] = var globals()[key] = var builtins.__dict__[key] = var k = 'grid_mid' if k in sdfdict: vargrid = sdfdict[k] grid_mid = vargrid keys = 'xc', 'yc', 'zc' for n in range(np.size(vargrid.dims)): key = keys[n] var = vargrid.data[n] dims = str(tuple(int(i) for i in sdfdict[k].dims)) if verbose: print(key + dims + ' = ' + k) fdict[key] = var globals()[key] = var builtins.__dict__[key] = var # Export particle arrays for k, value in data.__dict__.items(): if type(value) != sdf.BlockPointVariable \ and type(value) != sdf.BlockPointMesh: continue key = re.sub(r'[^a-z0-9]', '_', value.id.lower()) if hasattr(value, "data"): var = value.data else: var = value dims = str(tuple(int(i) for i in value.dims)) if type(value) == sdf.BlockPointVariable: if verbose: print(key + dims + ' = ' + value.name) fdict[key] = var globals()[key] = var builtins.__dict__[key] = var else: vargrid = value grid = vargrid keys = 'x', 'y', 'z' for n in range(np.size(value.dims)): gkey = keys[n] + '_' + key var = value.data[n] dims = str(tuple(int(i) for i in value.dims)) if verbose: print(gkey + dims + ' = ' + k + ' ' + keys[n]) fdict[gkey] = var globals()[gkey] = var builtins.__dict__[gkey] = var # X, Y = np.meshgrid(x, y) return data
c('springgreen'), c('yellow'), 0.6, c('yellow'), c('red'), 0.8, c('red'), c('firebrick') ]) color_list = ['blue', 'limegreen', 'red'] if __name__ == '__main__': from_path = './cannon_a190_v484/' to_path = './cannon_a190_v484_fig/' ######### Script code drawing figure ################ for n in range(11, 23, 1): data = sdf.read(from_path + 'q' + str(n).zfill(4) + ".sdf", dict=True) header = data['Header'] time = header['time'] x = data['Grid/Grid_mid'].data[0] / 1.0e-6 y = data['Grid/Grid_mid'].data[1] / 1.0e-6 z = data['Grid/Grid_mid'].data[2] / 1.0e-6 X, Z = np.meshgrid(x, z) data = sdf.read(from_path + 'e_fields' + str(n).zfill(4) + ".sdf", dict=True) ey1 = data['Electric Field/Ez_averaged'].data / exunit * 3.5 ey = np.sum(ey1[:, 179:181, :], axis=1) / 2 data = sdf.read('../alex_ion_acc/uniform_a190_n30/e_fields' + str(n).zfill(4) + ".sdf", dict=True) ey1 = data['Electric Field/Ez_averaged'].data / exunit * 3.5
def processplot(n): to_path='./cannon_a190_bulk200/' from_path = './cannon_a190_bulk200/' ######### Parameter you should set ########### n0=30.0 R=1.8e-6 L=15e-6 Ntot = np.pi*R*R*L*n0*denunit V=(1.0/20.0)*(1.0/15.0)*(1.0/15.0)*1.0e-18 weight = V*denunit*n0/50.0 # weight = Ntot/(1200*360*360*50) set_relativistic =1 if 1 > 0: data = sdf.read(from_path+"i_tot_loc"+str(n).zfill(4)+".sdf",dict=True) header=data['Header'] time1=header['time'] if set_relativistic == 1: px = data['Particles/Px/subset_Only_Ions0/Ion'].data/(1836*m0*v0) py = data['Particles/Py/subset_Only_Ions0/Ion'].data/(1836*m0*v0) pz = data['Particles/Pz/subset_Only_Ions0/Ion'].data/(1836*m0*v0) gg = (px**2+py**2+pz**2+1)**0.5 theta = np.arctan2((py**2+pz**2)**0.5,px)*180.0/np.pi ek_1 = (gg - 1.0)*0.51*1836 ww_1 = np.zeros_like(ek_1) + weight dist_x1, den1 = pxpy_to_energy(ek_1,ww_1) ek_2 = (gg[abs(theta)<10.0] - 1.0)*0.51*1836 ww_2 = np.zeros_like(ek_2) + weight dist_x2, den2 = pxpy_to_energy(ek_2,ww_2) print('set_relativistic 1'+str(n).zfill(4)) elif set_relativistic == 0: px = data['Particles/Px/subset_Only_Ions0/Ion'].data py = data['Particles/Py/subset_Only_Ions0/Ion'].data pz = data['Particles/Pz/subset_Only_Ions0/Ion'].data pp = (px**2+py**2+pz**2)**0.5 theta = np.arctan2((py**2+pz**2)**0.5,px)*180.0/np.pi ek_1 = pp**2/2.0/1836/m0/(1.6e-13) ww_1 = np.zeros_like(ek_1) + weight dist_x1, den1 = pxpy_to_energy(ek_1,ww_1) ek_2 = (pp[abs(theta)<10.0])**2/2.0/1836/m0/(1.6e-13) ww_2 = np.zeros_like(ek_2) + weight dist_x2, den2 = pxpy_to_energy(ek_2,ww_2) print('set_relativistic 0'+str(n).zfill(4)) plt.plot(dist_x1,den1,':b',linewidth=4, label=str(round(time1/1e-15,0))+'; total') plt.plot(dist_x2,den2,':r',linewidth=4, label=str(round(time1/1e-15,0))+'; '+r'$\theta$'+'< 10$^o$') #### manifesting colorbar, changing label and axis properties #### plt.xlabel('Energy [MeV]',fontdict=font) plt.ylabel('dN/dE [per MeV]',fontdict=font) plt.xticks(fontsize=20); plt.yticks(fontsize=20); plt.yscale('log') #plt.ylim(2e7,8e9) plt.xlim(5,1000) plt.grid(which='major',color='k', linestyle='--', linewidth=0.3) plt.grid(which='minor',color='k', linestyle='--', linewidth=0.1) plt.legend(loc='best',fontsize=20,framealpha=1.0) plt.subplots_adjust(left=None, bottom=0.15, right=0.95, top=0.95, wspace=None, hspace=None) # plt.text(250,6e9,'t='+str(round(time/1.0e-15,0))+' fs',fontdict=font) fig = plt.gcf() fig.set_size_inches(10.0, 6.0) fig.savefig(to_path+'proton_spectrum_'+str(n).zfill(4)+'.png',format='png',dpi=80) plt.close("all") print('finished!'+str(n).zfill(4))
gg = (px**2 + py**2 + 1)**0.5 R = gg - px theta = np.arctan2(py, px) number = 400 plt.subplot(2, 1, 1) #axin1 = inset_axes(ax, width='15%', height='5%', loc='upper left') #axin2 = inset_axes(ax, width='15%', height='5%', loc='upper center') grid_t = np.zeros(130) grid_x = np.linspace(10, 14.9833, 150) grid_data = np.zeros([130, 150]) index = 68 for n in range(5, 130, 1): data = sdf.read("./Data_a20_130_2/" + str(n).zfill(4) + ".sdf", dict=True) header = data['Header'] grid_t[n] = header['time'] / 1e-15 y = data['Grid/Grid_mid'].data[1] / 1.0e-6 name = 'ex' ex = data['Electric Field/' + str.capitalize(name)].data / exunit yi = np.min(np.where(yy[index, (n - 5) * 10] < y)) print(np.shape(ex[0 + (n - 5) * 30:150 + (n - 5) * 30, yi])) grid_data[n, :] = (ex[0 + (n - 5) * 30:150 + (n - 5) * 30, yi] + ex[0 + (n - 5) * 30:150 + (n - 5) * 30, yi - 1]) * 0.5 X, Y = np.meshgrid(grid_t, grid_x) levels = np.linspace(-2.1, 2.1, 50) grid_data[grid_data < -2] = -2 grid_data[grid_data > 2] = 2
class MidpointNormalize(colors.Normalize): def __init__(self, vmin=None, vmax=None, midpoint=None, clip=False): self.midpoint = midpoint colors.Normalize.__init__(self, vmin, vmax, clip) def __call__(self, value, clip=None): # I'm ignoring masked values and all kinds of edge cases to make a # simple example... x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1] return np.ma.masked_array(np.interp(value, x, y)) ##end for norm colorbar#### #if __name__ == '__main__': ######### Parameter you should set ########### #start = 210 # start time #stop = 210 # end time #step = 1 # the interval or step # youwant = ['electron_x_px','electron_density','electron_en','electron_theta_en','ey'] #,'electron_ekbar'] #youwant field ex,ey,ez,bx,by,bz,ex_averaged,bx_averaged... #youwant Derived electron_density,electron_ekbar... #youwant dist_fn electron_x_px, electron_py_pz, electron_theta_en... #if (os.path.isdir('jpg') == False): # os.mkdir('jpg') #from_path = './uniform_a190_n30/' n = 4 dim = '2d' from_path = './one_20/' to_path = from_path ######### Script code drawing figure ################ #for n in range(start,stop+step,step): #### header data #### data = sdf.read(from_path+'ekbar'+str(n).zfill(4)+".sdf",dict=True) header=data['Header'] time=header['time'] x = data['Grid/Grid_mid'].data[0]/1.0e-6 print('ok') y = data['Grid/Grid_mid'].data[1]/1.0e-6 if dim == '3d': z = data['Grid/Grid_mid'].data[2]/1.0e-6 X, Y = np.meshgrid(x, y) name='Electron_ekbar' #den = data['Derived/EkBar_averaged/'+name[0:-6]].data/(0.51*q0*1.0e6) ekbar = data['Derived/EkBar/'+name[0:-6]].data/(0.51*q0*1.0e6) if dim == '3d': n3d = len(ekbar[0,0,:]) ekbar = (ekbar[:,:,n3d//2-1]+ekbar[:,:,n3d//2])/2.0 eee = 600.0 levels_ek = np.linspace(0, eee, 101) ekbar.T[ekbar.T > eee]=eee data = sdf.read(from_path+'q'+str(n).zfill(4)+".sdf",dict=True) den = (data['Derived/Number_Density/Electron'].data+data['Derived/Number_Density/E_1'].data)/denunit if dim == '3d': n3d = len(den[0,0,:]) den = (den[:,:,n3d//2-1]+den[:,:,n3d//2])/2.0 eee = 6.0 levels = np.linspace(0, eee, 101) den.T[den.T > eee]=eee data = sdf.read(from_path+'q'+str(n).zfill(4)+".sdf",dict=True) den_a = (data['Derived/Number_Density_averaged/Electron'].data+data['Derived/Number_Density_averaged/E_1'].data)/denunit if dim == '3d': n3d = len(den_a[0,0,:]) den_a = (den_a[:,:,n3d//2-1]+den_a[:,:,n3d//2])/2.0 #den_a.T[den_a.T > eee_a]=eee_a #ax=plt.subplot(3,2,1) ax=plt.subplot2grid((3, 3), (0, 0)) #axin1 = inset_axes(ax, width='15%', height='5%', loc='upper left',pad=0.2) #axin2 = inset_axes(ax, width='15%', height='5%', loc='lower left',pad=0.2) #axin1 = inset_axes(ax,width="5%",height="45%",loc='upper right', bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0,) #axin2 = inset_axes(ax,width="5%",height="45%",loc='lower right', bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0,) #### manifesting colorbar, changing label and axis properties #### image1=ax.contourf(X, Y, den.T, levels=levels, norm=mcolors.Normalize(vmin=levels.min(), vmax=levels.max()), cmap=mycolor_viridis) # ax.contour(X, Y, den_a.T, levels=[0.9], colors='limegreen', linewidths=3.5,origin='lower') # cbar=plt.colorbar(image1,pad=0.01,ticks=np.linspace(0.0, eee, 5),orientation="vertical") # cbar.set_label('$n_e$ [$n_c$]', fontdict=font2) # cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=font2['size']) #### manifesting colorbar, changing label and axis properties #### # cbar=plt.colorbar(image2,pad=0.01,ticks=np.linspace(-eee, eee, 5),orientation="vertical") # cbar.set_label(r'$E_y\ [m_ec\omega_0/e]$',fontdict=font2) # cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=font2['size']) # plt.title('Ey_den_e at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) ax.text(2.,4.5,'t = '+str(round(time/1.0e-15,0))+' fs',fontdict=font,color='black') #ax.text(21.,1.75,'t = 70 fs',fontdict=font) ax.set_ylim(-6.5,6.5) ax.set_xlim(-5,15) # ax.set_xlabel('X [$\lambda$]',fontdict=font) ax.set_ylabel('Y [$\mu m$]',fontdict=font) ax.tick_params(axis='y',labelsize=25) ax.tick_params(axis='x',labelsize=0.0) # ax.tick_params(axis='both',labelsize=25) ax.set_xticks(ticks=[0,10]) ax.set_yticks(ticks=[-5,0,5]) #ax=plt.subplot(3,1,1) ax=plt.subplot2grid((3, 3), (1, 0)) #axin1 = inset_axes(ax, width='15%', height='5%', loc='upper left',pad=0.2) #axin2 = inset_axes(ax, width='15%', height='5%', loc='lower left',pad=0.2) #axin1 = inset_axes(ax,width="5%",height="45%",loc='upper right', bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0,) #axin2 = inset_axes(ax,width="5%",height="45%",loc='lower right', bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0,) #### manifesting colorbar, changing label and axis properties #### image1=ax.contourf(X, Y, ekbar.T, levels=levels_ek, norm=mcolors.Normalize(vmin=levels_ek.min(), vmax=levels_ek.max()), cmap=mycolor_jet) image1=ax.contour(X, Y, den_a.T, levels=[19.5], colors='k', linewidths=2,origin='lower') # cbar=plt.colorbar(image1,pad=0.01,ticks=np.linspace(0.0, eee, 5),orientation="vertical") # cbar.set_label('$n_e$ [$n_c$]', fontdict=font2) # cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=font2['size']) ax.set_ylim(-6.5,6.5) ax.set_xlim(-5,15) # ax.set_xlabel('X [$\lambda$]',fontdict=font) ax.set_ylabel('Y [$\mu m$]',fontdict=font) ax.tick_params(axis='y',labelsize=25) ax.tick_params(axis='x',labelsize=0.0) # ax.tick_params(axis='both',labelsize=25) ax.set_xticks(ticks=[0,10]) ax.set_yticks(ticks=[-5,0,5]) #ax=plt.subplot(3,1,2) ax=plt.subplot2grid((3, 3), (2, 0)) data = sdf.read(from_path+'current'+str(n).zfill(4)+".sdf",dict=True) ex = data['Current/Jx_averaged'].data/jalf/4/np.pi if dim == '3d': ex = (ex[:,:,n3d//2-1]+ex[:,:,n3d//2])/2.0 eee = 0.2 levels = np.linspace(-eee, eee, 51) ex.T[ex.T < -eee]=-eee ex.T[ex.T > eee]= eee image2=ax.contourf(X, Y, ex.T, levels=levels, cmap='bwr') #### manifesting colorbar, changing label and axis properties #### # cbar=plt.colorbar(image2,pad=0.01,ticks=np.linspace(-eee, eee, 5),orientation="vertical") # cbar.set_label(r'$\alpha=j_x/[4\pi I_A/\lambda^2]$',fontdict=font2) # cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=font2['size']) # plt.title('Jx_averaged at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) #ax.text(21.,1.75,'t = '+str(round(time/1.0e-15,0))+' fs',fontdict=font) #ax.text(21.,1.75,'t = 70 fs',fontdict=font) # ax.contour(X, Y, den_a.T, levels=[0.9], colors='limegreen', linewidths=2,origin='lower') image1=ax.contour(X, Y, den_a.T, levels=[19.5], colors='k', linewidths=2,origin='lower') ax.set_ylim(-6.5,6.5) ax.set_xlim(-5,15) ax.set_xlabel('X [$\mu m$]',fontdict=font) ax.set_ylabel('Y [$\mu m$]',fontdict=font) ax.tick_params(axis='y',labelsize=25) ax.tick_params(axis='x',labelsize=25) ax.set_xticks(ticks=[0,10]) ax.set_yticks(ticks=[-5,0,5]) n = 13 dim = '2d' ######### Script code drawing figure ################ #for n in range(start,stop+step,step): #### header data #### data = sdf.read(from_path+'ekbar'+str(n).zfill(4)+".sdf",dict=True) header=data['Header'] time=header['time'] x = data['Grid/Grid_mid'].data[0]/1.0e-6 print('ok') y = data['Grid/Grid_mid'].data[1]/1.0e-6 if dim == '3d': z = data['Grid/Grid_mid'].data[2]/1.0e-6 X, Y = np.meshgrid(x, y) name='Electron_ekbar' #den = data['Derived/EkBar_averaged/'+name[0:-6]].data/(0.51*q0*1.0e6) ekbar = data['Derived/EkBar/'+name[0:-6]].data/(0.51*q0*1.0e6) if dim == '3d': n3d = len(ekbar[0,0,:]) ekbar = (ekbar[:,:,n3d//2-1]+ekbar[:,:,n3d//2])/2.0 eee = 600.0 levels_ek = np.linspace(0, eee, 101) ekbar.T[ekbar.T > eee]=eee data = sdf.read(from_path+'q'+str(n).zfill(4)+".sdf",dict=True) den = (data['Derived/Number_Density/Electron'].data+data['Derived/Number_Density/E_1'].data)/denunit if dim == '3d': n3d = len(den[0,0,:]) den = (den[:,:,n3d//2-1]+den[:,:,n3d//2])/2.0 eee = 6.0 levels = np.linspace(0, eee, 101) den.T[den.T > eee]=eee data = sdf.read(from_path+'q'+str(n).zfill(4)+".sdf",dict=True) den_a = (data['Derived/Number_Density_averaged/Electron'].data+data['Derived/Number_Density_averaged/E_1'].data)/denunit if dim == '3d': n3d = len(den_a[0,0,:]) den_a = (den_a[:,:,n3d//2-1]+den_a[:,:,n3d//2])/2.0 #den_a.T[den_a.T > eee]=eee den_a.T[Y>4] = 20.0 #ax=plt.subplot(3,2,1) ax=plt.subplot2grid((3, 3), (0, 1), colspan=2) #axin1 = inset_axes(ax, width='15%', height='5%', loc='upper left',pad=0.2) #axin2 = inset_axes(ax, width='15%', height='5%', loc='lower left',pad=0.2) #axin1 = inset_axes(ax,width="5%",height="45%",loc='upper right', bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0,) #axin2 = inset_axes(ax,width="5%",height="45%",loc='lower right', bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0,) #### manifesting colorbar, changing label and axis properties #### image1=ax.contourf(X, Y, den.T, levels=levels, norm=mcolors.Normalize(vmin=levels.min(), vmax=levels.max()), cmap=mycolor_viridis) # ax.contour(X, Y, den_a.T, levels=[0.9], colors='limegreen', linewidths=3.5,origin='lower') # cbar=plt.colorbar(image1,pad=0.01,ticks=np.linspace(0.0, eee, 5),orientation="vertical") # cbar.set_label('$n_e$ [$n_c$]', fontdict=font2) # cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=font2['size']) #### manifesting colorbar, changing label and axis properties #### # cbar=plt.colorbar(image2,pad=0.01,ticks=np.linspace(-eee, eee, 5),orientation="vertical") # cbar.set_label(r'$E_y\ [m_ec\omega_0/e]$',fontdict=font2) # cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=font2['size']) # plt.title('Ey_den_e at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) ax.text(42.,4.5,'t = '+str(round(time/1.0e-15,0))+' fs',fontdict=font,color='black') #ax.text(21.,1.75,'t = 70 fs',fontdict=font) ax.set_ylim(-6.5,6.5) ax.set_xlim(15,55) # ax.set_xlabel('X [$\lambda$]',fontdict=font) # ax.set_ylabel('Y [$\mu m$]',fontdict=font) ax.tick_params(axis='y',labelsize=0.0) ax.tick_params(axis='x',labelsize=0.0) # ax.tick_params(axis='both',labelsize=25) ax.set_xticks(ticks=[20,30,40,50]) ax.set_yticks(ticks=[-5,0,5]) #ax=plt.subplot(3,1,1) ax=plt.subplot2grid((3, 3), (1, 1), colspan=2) #axin1 = inset_axes(ax, width='15%', height='5%', loc='upper left',pad=0.2) #axin2 = inset_axes(ax, width='15%', height='5%', loc='lower left',pad=0.2) #axin1 = inset_axes(ax,width="5%",height="45%",loc='upper right', bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0,) #axin2 = inset_axes(ax,width="5%",height="45%",loc='lower right', bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0,) #### manifesting colorbar, changing label and axis properties #### image1=ax.contourf(X, Y, ekbar.T, levels=levels_ek, norm=mcolors.Normalize(vmin=levels_ek.min(), vmax=levels_ek.max()), cmap=mycolor_jet) image1=ax.contour(X, Y, den_a.T, levels=[19.5], colors='k', linewidths=2,origin='lower') # cbar=plt.colorbar(image1,pad=0.01,ticks=np.linspace(0.0, eee, 5),orientation="vertical") # cbar.set_label('$n_e$ [$n_c$]', fontdict=font2) # cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=font2['size']) ax.set_ylim(-6.5,6.5) ax.set_xlim(15,55) # ax.set_xlabel('X [$\lambda$]',fontdict=font) # ax.set_ylabel('Y [$\mu m$]',fontdict=font) ax.tick_params(axis='y',labelsize=0.0) ax.tick_params(axis='x',labelsize=0.0) # ax.tick_params(axis='both',labelsize=25) ax.set_xticks(ticks=[20,30,40,50]) ax.set_yticks(ticks=[-5,0,5]) #ax=plt.subplot(3,1,2) ax=plt.subplot2grid((3, 3), (2, 1), colspan=2) data = sdf.read(from_path+'current'+str(n).zfill(4)+".sdf",dict=True) ex = data['Current/Jx_averaged'].data/jalf/4/np.pi if dim == '3d': ex = (ex[:,:,n3d//2-1]+ex[:,:,n3d//2])/2.0 print(np.max(abs(ex))) eee = 0.2 levels = np.linspace(-eee, eee, 51) ex.T[ex.T < -eee]=-eee ex.T[ex.T > eee]= eee image2=ax.contourf(X, Y, ex.T, levels=levels, cmap='bwr') #### manifesting colorbar, changing label and axis properties #### # cbar=plt.colorbar(image2,pad=0.01,ticks=np.linspace(-eee, eee, 5),orientation="vertical") # cbar.set_label(r'$\alpha=j_x/[4\pi I_A/\lambda^2]$',fontdict=font2) # cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=font2['size']) # plt.title('Jx_averaged at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) #ax.text(21.,1.75,'t = '+str(round(time/1.0e-15,0))+' fs',fontdict=font) #ax.text(21.,1.75,'t = 70 fs',fontdict=font) # ax.contour(X, Y, den_a.T, levels=[0.9], colors='limegreen', linewidths=2,origin='lower') image1=ax.contour(X, Y, den_a.T, levels=[19.5], colors='k', linewidths=2,origin='lower') ax.set_ylim(-6.5,6.5) ax.set_xlim(15,55) ax.set_xlabel('X [$\mu m$]',fontdict=font) # ax.set_ylabel('Y [$\mu m$]',fontdict=font) ax.tick_params(axis='y',labelsize=0) ax.tick_params(axis='x',labelsize=25) ax.set_xticks(ticks=[20,30,40,50]) ax.set_yticks(ticks=[-5,0,5]) ## ax=plt.subplot(3,1,3) ## if dim == '3d': ## Y, Z = np.meshgrid(y, z) ## R = (Y**2+Z**2)**0.5 ## elif dim == '2d': ## R = abs(y) ## x1 = np.linspace(-5,75,600) ## J1 = 0.3*(2*np.pi)**2*3.2**2 ## J2 = 0.056*(2*np.pi)**2*3.2**2 ## y1 = np.zeros_like(x1) ## y1[(x1>10)&(x1<45)] = J1 ## y2 = np.zeros_like(x1)+J2 ## ## ax.plot(x1, y2, '--r', linewidth=3,label=r'$-J_x=\alpha^*(2\pi r/\lambda)^2J_A,\ \alpha^*=0.056$',zorder=0) ### ax.plot(x1, y1, '--b', linewidth=3,label=r'$-J_x=\alpha(2\pi r/\lambda)^2J_A,\ \ \ \alpha=0.30$',zorder=1) ## data = sdf.read(from_path+'current'+str(n).zfill(4)+".sdf",dict=True) ## ex = data['Current/Jx_averaged'].data ## Jx = np.sum(ex[:,R<2.5],1)*3.14*(1e-6/30)*5.0e-6/17e3 ## ax.plot(x, -Jx, '-b', linewidth=3,label='3D-PIC simulation') ## ax.set_xlim(-5,75) ## ax.set_xlabel('X [$\mu m$]',fontdict=font) ## ax.set_ylabel('$-J_x$ [$J_A$]',fontdict=font) ## ax.tick_params(axis='y',labelsize=25) ## ax.tick_params(axis='x',labelsize=25) ## ax.legend(loc='best',fontsize=16,framealpha=0.0) plt.subplots_adjust(left=0.08, bottom=0.14, right=0.99, top=0.95, wspace=0.055, hspace=0.025) #ax.set_xticklabels(xticklabels,fontdict=font) #ax.set_yticklabels(yticklabels,fontdict=font) # plt.subplot(gs[0]) # plt.scatter(ppp_x[abs(ppp_y)<=3.2],ppp_px[abs(ppp_y)<=3.2],s=10,c='green',edgecolors='None',alpha=0.5) # plt.xlim(0,30) # plt.ylabel('p$_x$ [m$_e$c]', fontdict=font) # plt.xticks([]) # plt.yticks(fontsize=20) # # plt.subplot(gs[3]) # plt.scatter(ppp_py[abs(ppp_y)<=3.2],ppp_y[abs(ppp_y)<=3.2],s=10,c='green',edgecolors='None',alpha=0.5) # plt.ylim(-6.5,6.5) # plt.xlabel('p$_y$ [m$_e$c]', fontdict=font) # plt.yticks([]) # plt.xticks(fontsize=20) # # # plt.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.011, hspace=0.051) # #fig=plt.subplot(gs[1]) #ax1 = fig.add_axes([0.05, 0.85, 0.9, 0.10]) #ax2 = fig.add_axes([0.05, 0.35, 0.9, 0.10]) #cmap = mpl.cm.rainbow #norm = mpl.colors.Normalize(vmin=0.0, vmax=50) #cb1 = mpl.colorbar.ColorbarBase(ax1, cmap='Greys', # norm=norm, # orientation='horizontal',ticks=np.linspace(0.00, 50, 6)) #cb1.set_label('n$_e$ [n$_c$]') #cmap = mpl.colors.ListedColormap(['r', 'g', 'b', 'c']) #cmap.set_over('0.25') #cmap.set_under('0.75') #cmap = mpl.cm.BrBG #Bz = 22.5 #norm = mpl.colors.Normalize(vmin=-abs(Bz), vmax=abs(Bz)) #cb2 = mpl.colorbar.ColorbarBase(ax2, cmap=cmap_br, # norm=norm, # orientation='horizontal',ticks=np.linspace(-abs(Bz), abs(Bz), 5),alpha=0.7) #cb2.set_label(r'E$_y$ [m$_e\omega$/e]') #cmap = mpl.colors.ListedColormap(['r', 'g', 'b', 'c']) #cmap.set_over('0.25') #cmap.set_under('0.75') fig = plt.gcf() fig.set_size_inches(14, 14.) fig.savefig(to_path+'wrap_current.png',format='png',dpi=160) plt.close("all")
def processplot(n): ######### Parameter you should set ########### #start = 23 # start time #stop = 30 # end time #step = 1 # the interval or step #youwant = ['ey','ex','ey_averaged','bz','bz_averaged'] #,'electron_en','electron_ekbar','electron_density'] #youwant.append('Ion_ekbar') #youwant.append('positron_ekbar') #youwant.append('electron_en') #youwant.append('photon_en') #youwant field ex,ey,ez,bx,by,bz,ex_averaged,bx_averaged... #youwant Derived electron_density,electron_ekbar... #youwant dist_fn electron_x_px... from_path = './cannon_a190/' to_path = from_path n0 = 30.0 R = 1.8e-6 L = 15e-6 Ntot = np.pi * R * R * L * n0 * denunit V = (1.0 / 20.0) * (1.0 / 15.0) * (1.0 / 15.0) * 1.0e-18 weight = V * denunit * n0 / 50.0 data = sdf.read(from_path + "i_tot_loc" + str(n).zfill(4) + ".sdf", dict=True) header = data['Header'] time1 = header['time'] px = data['Particles/Px/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) py = data['Particles/Py/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) pz = data['Particles/Pz/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) gg = (px**2 + py**2 + pz**2 + 1)**0.5 theta = np.arctan2((py**2 + pz**2)**0.5, px) * 180.0 / np.pi grid_x = data['Grid/Particles/subset_Only_Ions0/Ion'].data[0] / 1.0e-6 temp_id = data['Particles/ID/subset_Only_Ions0/Ion'].data px = px[theta < 10] grid_x = grid_x[theta < 10] theta = theta[theta < 10] if np.size(px) == 0: return 0 theta[theta < -10] = -10 theta[theta > 10] = 10 color_index = abs(theta) print('hehe1') weight = np.zeros_like(grid_x) + weight print(max(weight), min(weight)) ######### Script code drawing figure ################ #for n in range(start,stop+step,step): #### header data #### #data = sdf.read(from_path+str(n).zfill(4)+".sdf",dict=True) #header=data['Header'] #time=header['time'] #x = data['Grid/Grid_mid'].data[0]/1.0e-6 #y = data['Grid/Grid_mid'].data[1]/1.0e-6 #X, Y = np.meshgrid(x, y) from_path_2 = './cannon_a190_e_div/' data = sdf.read(from_path_2 + 'q' + str(n).zfill(4) + ".sdf", dict=True) header = data['Header'] time = header['time'] x = data['Grid/Grid_mid'].data[0] / 1.0e-6 y = data['Grid/Grid_mid'].data[1] / 1.0e-6 z = data['Grid/Grid_mid'].data[2] / 1.0e-6 X, Y, Z = np.meshgrid(x, y, z, sparse=False, indexing='ij') RR = (Y**2 + Z**2)**0.5 data_ne_in = data['Derived/Number_Density/E_in'].data / denunit + data[ 'Derived/Number_Density/E_in_1'].data / denunit data_ne_out = data['Derived/Number_Density/E_out'].data / denunit + data[ 'Derived/Number_Density/E_out_1'].data / denunit data_np = data['Derived/Number_Density/Ion'].data / denunit + data[ 'Derived/Number_Density/Ion_1'].data / denunit data_nc = data['Derived/Number_Density/Carbon'].data / denunit + data[ 'Derived/Number_Density/Carbon_1'].data / denunit data_1 = sdf.read(from_path + 'e_fields' + str(n).zfill(4) + ".sdf", dict=True) data_ex = data_1['Electric Field/' + str.capitalize('ex_averaged')].data / exunit for R_lim in range(5, 45, 5): eexx = data_ex[:, RR[0, :, :] < R_lim / 10.] # print(eexx.shape) n_size = eexx[-1, :].size value_ex = np.sum(eexx, axis=1) / n_size eexx = data_ne_in[:, RR[0, :, :] < R_lim / 10.] # print(eexx.shape) n_size = eexx[-1, :].size value_n_e_in = np.sum(eexx, axis=1) / n_size eexx = data_ne_out[:, RR[0, :, :] < R_lim / 10.] # print(eexx.shape) n_size = eexx[-1, :].size value_n_e_out = np.sum(eexx, axis=1) / n_size eexx = data_np[:, RR[0, :, :] < R_lim / 10.] # print(eexx.shape) n_size = eexx[-1, :].size value_n_p = np.sum(eexx, axis=1) / n_size eexx = data_nc[:, RR[0, :, :] < R_lim / 10.] # print(eexx.shape) n_size = eexx[-1, :].size value_n_c = np.sum(eexx, axis=1) / n_size # plt.subplot() # plt.scatter(grid_x, px, c=color_index, s=0.03, cmap='rainbow_r', edgecolors='None', alpha=0.66) #plt.hist2d(grid_x, px, bins=(50, 50), range=[[10,50],[0,1.5]], cmap=plt.cm.jet, weights=weight, norm=mcolors.Normalize(vmin=-2.0, vmax=2.0)) fig, host = plt.subplots() plt.hist2d(grid_x, px, bins=(100, 100), range=[[15, 45], [0, 1.5]], cmap='cubehelix_r', weights=weight, normed=False, norm=colors.Normalize(vmin=0, vmax=1e9)) cbar = plt.colorbar(pad=0.1) cbar.set_label(r'$dN/(dxdp_x)$' + ' [A.U.]', fontdict=font) cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(), fontsize=20) #plt.plot(np.linspace(-500,900,1001), np.zeros([1001]),':k',linewidth=2.5) #plt.plot(np.zeros([1001]), np.linspace(-500,900,1001),':k',linewidth=2.5) #plt.plot(np.linspace(-500,900,1001), np.linspace(-500,900,1001),'-g',linewidth=3) #plt.plot(np.linspace(-500,900,1001), 200-np.linspace(-500,900,1001),'-',color='grey',linewidth=3) # plt.legend(loc='upper right') plt.xlim(15, 45) plt.ylim(0., 1.5) plt.xlabel('X [$\mu m$]', fontdict=font) plt.ylabel('$p_x$ [m$_i$c$^2$]', fontdict=font) plt.xticks([15, 25, 35, 45], fontsize=25) plt.yticks([0, 0.5, 1.0, 1.5], fontsize=25) # plt.text(-100,650,' t = '++' fs',fontdict=font) plt.subplots_adjust(left=0.16, bottom=None, right=0.97, top=None, wspace=None, hspace=None) plt.title('At ' + str(round(time1 / 1.0e-15, 2)) + ' fs', fontdict=font) print('hehe') #plt.show() #lt.figure(figsize=(100,100)) par1 = host.twinx() #par2 = host.twinx() #par3 = host.twinx() #par2.spines["right"].set_position(("axes", 1.05)) #make_patch_spines_invisible(par2) #par2.spines["right"].set_visible(True) #par3.spines["right"].set_position(("axes", 1.1)) #make_patch_spines_invisible(par3) #par3.spines["right"].set_visible(True) tkw = dict(size=25, width=2.) p1, = par1.plot(x, value_ex, "-", color='lime', label="$E_x$", linewidth=3) par1.set_ylim(0, 5) p1, = par1.plot(x, value_n_e_in + value_n_e_out, "-b", label="$n_e$", linewidth=3) p1, = par1.plot(x, value_n_e_in, "-c", label="$n_e-in$", linewidth=3) p1, = par1.plot(x, value_n_e_out, "-", color='orange', label="$n_e-out$", linewidth=3) p1, = par1.plot(x, value_n_p + value_n_c * 6, "-r", label="$Z_in_i$", linewidth=3) # p3, = par3.plot(x,iden, "-r", label="Ion") # p3, = par3.plot(x,iden, "-y", label="Ion") # p3, = par3.plot(x,cden*6, "-g", label="Ion") # par3.set_ylabel('$n^+\ [n_c]$') par1.legend(loc='middle right', fontsize=20, framealpha=1.0) par1.set_ylim(0, 5) par1.set_ylabel('$E_x$ [$m_ec\omega/|e|$] & $n_e$($Z_in_i$) [$n_c$]', fontdict=font, color='r') par1.tick_params(axis='y', labelsize=25, colors='r') fig = plt.gcf() fig.set_size_inches(12, 7.5) fig.savefig(from_path_2 + 'new_cut_px_x_phase_' + str(n).zfill(4) + '_r' + str(R_lim).zfill(2) + '.png', format='png', dpi=160) plt.close("all") print('finised cut_px_x_phase_' + str(n).zfill(4) + '_r' + str(R_lim).zfill(2) + '.png') return 0
# fs = 16 grid_min_x = 500 grid_max_x = 2999 grid_min_y = 500 grid_max_y = 2499 Gx = np.linspace(0, lx, nx) Gy = np.linspace(0, ly, ny) gx = Gx[grid_min_x:grid_max_x + 1] gy = Gy[grid_min_y:grid_max_y + 1] file = '/Volumes/yaowp2016/flow-n1-q/' ii = 15 fname = file + str(ii).zfill(4) + '.sdf' datafile = sdf.read(fname) nbe = datafile.Derived_Number_Density_ele_bm.data / n0 nae = datafile.Derived_Number_Density_ele_e.data / n0 nqe = datafile.Derived_Number_Density_ele_qed.data / n0 nph = datafile.Derived_Number_Density_pho.data / n0 NBE = nbe[grid_min_x:grid_max_x + 1, grid_min_y:grid_max_y + 1].transpose() NAE = nae[grid_min_x:grid_max_x + 1, grid_min_y:grid_max_y + 1].transpose() NQE = nqe[grid_min_x:grid_max_x + 1, grid_min_y:grid_max_y + 1].transpose() NPH = nph[grid_min_x:grid_max_x + 1, grid_min_y:grid_max_y + 1].transpose() file = '/Volumes/yaowp2016/flow-n/' ii = 15 fname = file + str(ii).zfill(4) + '.sdf' datafile = sdf.read(fname) nbe1 = datafile.Derived_Number_Density_ele_bm.data / n0
exunit = m0*v0*frequency/q0 bxunit = m0*frequency/q0 denunit = frequency**2*epsilon0*m0/q0**2 print('electric field unit: '+str(exunit)) print('magnetic field unit: '+str(bxunit)) print('density unit nc: '+str(denunit)) font = {'family' : 'monospace', 'style' : 'normal', 'color' : 'black', 'weight' : 'normal', 'size' : 20, } data = sdf.read('./Data/'+str(12).zfill(4)+".sdf",dict=True) header=data['Header'] time=header['time'] px = data['Particles/Px/subset_high_e/electron'].data/(m0*v0) py = data['Particles/Py/subset_high_e/electron'].data/(m0*v0) grid_x = data['Grid/Particles/subset_high_e/electron'].data[0]/wavelength grid_y = data['Grid/Particles/subset_high_e/electron'].data[1]/wavelength work_x = data['Particles/Time_Integrated_Work_x/subset_high_e/electron'].data work_y = data['Particles/Time_Integrated_Work_y/subset_high_e/electron'].data #field_ex = data['Particles/field_ex/subset_high_e/electron'].data/exunit #field_ey = data['Particles/field_ey/subset_high_e/electron'].data/exunit #field_bz = data['Particles/field_bz/subset_high_e/electron'].data/bxunit gg = (px**2+py**2+1)**0.5 px = px [(abs(grid_y) < 3.2) & (gg > 200.0)]
mycolor_binary = matplotlib.colors.ListedColormap(cmap, name='myColorMap', N=cmap.shape[0]) upper = matplotlib.cm.Oranges(np.arange(256)) lower = np.ones((int(256/4),4)) for i in range(3): lower[:,i] = np.linspace(1, upper[0,i], lower.shape[0]) cmap = np.vstack(( lower, upper )) mycolor_orange = matplotlib.colors.ListedColormap(cmap, name='myColorMap', N=cmap.shape[0]) ######### Parameter you should set ########### from_path = './cannon_a190_v484/' to_path = './cannon_a190_v484_fig/' if not os.path.exists(to_path): os.mkdir(to_path) data = sdf.read(from_path+"i_tot_loc0027.sdf",dict=True) px = data['Particles/Px/subset_Only_Ions0/Ion'].data/(1836*m0*v0) py = data['Particles/Py/subset_Only_Ions0/Ion'].data/(1836*m0*v0) pz = data['Particles/Pz/subset_Only_Ions0/Ion'].data/(1836*m0*v0) theta = np.arctan2((py**2+pz**2)**0.5,px)*180.0/np.pi gg = (px**2+py**2+pz**2+1)**0.5 Ek = (gg-1)*1836*0.51 part13_id = data['Particles/ID/subset_Only_Ions0/Ion'].data part13_id = part13_id[ (Ek>220) & (abs(theta)<10) & (Ek<240)] print('part13_id size is ',part13_id.size,' max ',np.max(part13_id),' min ',np.min(part13_id)) x_start = 460 x_stop = 520 quiver_space = 5 ######### Script code drawing figure ################ n=17
font = { 'family': 'monospace', 'color': 'black', 'weight': 'normal', 'size': 20, } ######### Parameter you should set ########### start = 1 # start time stop = 49 # end time step = 1 # the interval or step # if (os.path.isdir('jpg') == False): # os.mkdir('jpg') ######### Script code drawing figure ################ for n in range(start, stop + step, step): #### header data #### data = sdf.read("./Data/" + str(n).zfill(4) + ".sdf", dict=True) header = data['Header'] time = header['time'] # if ( n==start ): # part_id = data['Particles/ID/subset_high_e/electron'].data # else: # part_id = np.intersect1d(data['Particles/ID/subset_high_e/electron'].data, part_id) part_id = data['Particles/ID/subset_high_e/electron'].data print('Particle_ID size is ', part_id.size, ' max ', np.max(part_id), ' min ', np.min(part_id)) print('finised ' + str(round(100.0 * (n - start + step) / (stop - start + step), 4)) + '%')
def processplot(n): from_path='./uniform_a190_n30/' to_path=from_path x_start=100; x_stop=700; y_start=60; y_stop=300; z_start=60; z_stop=300; x_size = x_stop-x_start; y_size = y_stop-y_start; z_size = z_stop-z_start name = 'Er_averaged' data = sdf.read(from_path+'e_fields'+str(n).zfill(4)+'.sdf',dict=True) header=data['Header'] time =header['time'] x = data['Grid/Grid_mid'].data[0]/1.e-6 y = data['Grid/Grid_mid'].data[1]/1.e-6 z = data['Grid/Grid_mid'].data[2]/1.e-6 var1 = data['Electric Field/Ey_averaged'].data/exunit var2 = data['Electric Field/Ez_averaged'].data/exunit var = (var1**2+var2**2)**0.5 X, Y, Z = np.meshgrid(x, y, z, sparse=False, indexing='ij') var = var[x_start:x_stop,y_start:y_stop,z_start:z_stop] X = X[x_start:x_stop,y_start:y_stop,z_start:z_stop] Y = Y[x_start:x_stop,y_start:y_stop,z_start:z_stop] Z = Z[x_start:x_stop,y_start:y_stop,z_start:z_stop] var = rebin3d(var, (x_size//2, y_size//2, z_size//2)) X = rebin3d(X, (x_size//2, y_size//2, z_size//2)) Y = rebin3d(Y, (x_size//2, y_size//2, z_size//2)) Z = rebin3d(Z, (x_size//2, y_size//2, z_size//2)) var = var.reshape(np.size(var)) var[var>20] = 20 X = X.reshape(np.size(X)) Y = Y.reshape(np.size(Y)) Z = Z.reshape(np.size(Z)) plotkws = {'marker':'.','edgecolors':'none'} norm = None index = 4.0 _abs = False # True is for ex; Flase is for density log = False elev = None azim = None if _abs: norm = 0 _min = max(np.max(var),np.min(var))**(0.002**(1.0/index)) if log else max(np.max(var),np.min(var))*0.002**(1.0/index) plt.set_cmap(reg_cmap_transparent('bwr',create_alpha(lambda x:abs(x/127.5-1)**index))) else: _min = np.max(var)**(0.002**(1.0/index)) if log else np.max(var)*0.002**(1.0/index) plt.set_cmap(reg_cmap_transparent('hsv_r',create_alpha(lambda x:abs(x/255.0)**index))) #special code _min = max(_min,1.1e27*0.8) # var._cutrange(lambda x : x[1] < 3) if log: plotkws['norm'] = matplotlib.colors.LogNorm() #var.cutrange(_min=_min,_abs=_abs) #point_scatter3D(var,norm=norm,plotkws=plotkws) #def point_scatter3D(var,elev=None,azim=None,hold=False,iso=False,norm=None,plotkws={}): cmap = plt.get_cmap() if norm is not None: v0 = np.min(var) - norm v1 = np.max(var) - norm if abs(v0/v1) > 1: low = 0 high = 0.5 * (1 - v1/v0) else: low = 0.5 * (1 + v0/v1) high = 1.0 cmap = plt.cm.colors.LinearSegmentedColormap.from_list('tr', cmap(np.linspace(low,high,256))) # print('here1') fig = plt.figure() ax = plt.axes(projection='3d') ax.view_init(elev=elev, azim=azim) # print('here2') im = ax.scatter(X, Y, Z, c=var, cmap=cmap, **plotkws) # print('here3') ax.set_xlabel('\n\nX'+ '[$\mu m$]',fontdict=font) ax.set_ylabel('\n\ny'+ '[$\mu m$]',fontdict=font) ax.set_zlabel('\n\nZ'+ '[$\mu m$]',fontdict=font) ax.set_xlim([x_start/20-5,x_stop/20-5]) ax.set_ylim([-(y_stop-y_start)/2/15-5,(y_stop-y_start)/2/15+5]) ax.set_zlim([-(z_stop-z_start)/2/15-5,(z_stop-z_start)/2/15+5]) #cbar=plt.colorbar(im, ticks=np.linspace(np.min(color_index), np.max(color_index), 5) ,pad=0.01) cbar=plt.colorbar(im, pad=0.01) cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(), fontsize=20) cbar.set_label(name+r'$[m_ec\omega/|e|]$',fontdict=font) #cbar.set_clim(300,600) #print('here4') for t in ax.xaxis.get_major_ticks(): t.label.set_fontsize(font_size) for t in ax.yaxis.get_major_ticks(): t.label.set_fontsize(font_size) for t in ax.zaxis.get_major_ticks(): t.label.set_fontsize(font_size) #plot for y_z plane Y,Z = np.meshgrid(y,z,indexing='ij') eexx = (var1**2+var2**2)**0.5 ex = (eexx[420-1,:,:]+eexx[420,:,:])/2 ex = ex[y_start:y_stop,z_start:z_stop] eee = 10.0 #np.max([np.max(ex),abs(np.min(ex))]) ex[ex>eee] = eee Y = Y[y_start:y_stop,z_start:z_stop] Z = Z[y_start:y_stop,z_start:z_stop] levels = np.linspace(0, eee, 40) im2=ax.contourf(ex.T, Y.T, Z.T, levels=levels, norm=mcolors.Normalize(vmin=0, vmax=eee), cmap=cm.gray_r, zdir='x', offset=x_start/20-5) # ax.set_xlim([x_start/20-5,x_stop/20-5]) # ax.set_xlim([-(y_stop-y_start)/2/12,(y_stop-y_start)/2/12]) # ax.set_ylim([-(z_stop-z_start)/2/12,(z_stop-z_start)/2/12]) cbar = plt.colorbar(im2, ticks=np.linspace(0, eee, 3)) cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(), fontsize=20) cbar.set_label(name+r'$[m_e\omega/|e|]$',fontdict=font) #plot for x_z plane X,Z = np.meshgrid(x,z,indexing='ij') eexx = data['Electric Field/Ez_averaged'].data/exunit ex = (eexx[:,(y_start+y_stop)//2-1,:]+eexx[:,(y_start+y_stop)//2,:])/2 ex = ex[x_start:x_stop,z_start:z_stop] X = X[x_start:x_stop,z_start:z_stop] Z = Z[x_start:x_stop,z_start:z_stop] if np.min(ex.T) == np.max(ex.T): #continue return eee = 10 levels = np.linspace(-eee, eee, 40) ex[ex>eee] = eee ex[ex<-eee] = -eee ax.contourf(X.T, ex.T, Z.T, levels=levels, norm=mcolors.Normalize(vmin=-eee, vmax=eee), cmap=cm.bwr, zdir='y', offset=(y_stop-y_start)/2/15+5) # ax.set_xlim([x_start/20-5,x_stop/20-5]) # ax.set_ylim([-(y_stop-y_start)/2/12,(y_stop-y_start)/2/12]) # ax.set_ylim([-(z_stop-z_start)/2/12,(z_stop-z_start)/2/12]) #plot for x_y plane X,Y = np.meshgrid(x,y,indexing='ij') eexx = data['Electric Field/Ey_averaged'].data/exunit ex = (eexx[:,:,(z_start+z_stop)//2-1]+eexx[:,:,(z_start+z_stop)//2])/2 ex = ex[x_start:x_stop,y_start:y_stop] X = X[x_start:x_stop,y_start:y_stop] Y = Y[x_start:x_stop,y_start:y_stop] if np.min(ex.T) == np.max(ex.T): #continue return eee = 10 levels = np.linspace(-eee, eee, 40) ex[ex>eee] = eee ex[ex<-eee] = -eee im2=ax.contourf(X.T, Y.T, ex.T, levels=levels, norm=mcolors.Normalize(vmin=-eee, vmax=eee), cmap=cm.bwr, zdir='z', offset=-(z_stop-z_start)/2/15-5) # ax.set_xlim([x_start/20-5,x_stop/20-5]) # ax.set_ylim([-(y_stop-y_start)/2/12,(y_stop-y_start)/2/12]) # ax.set_zlim([-(z_stop-z_start)/2/12,(z_stop-z_start)/2/12]) cbar = plt.colorbar(im2, ticks=np.linspace(-eee, eee, 5)) cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(), fontsize=20) cbar.set_label(r'$E_r\ [m_ec\omega/|e|]$',fontdict=font) plt.show() ax.grid(False) ax.xaxis.pane.set_edgecolor('black') ax.yaxis.pane.set_edgecolor('black') ax.zaxis.pane.set_edgecolor('black') ax.xaxis.pane.fill = False ax.yaxis.pane.fill = False ax.zaxis.pane.fill = False #ax.grid(linestyle='None', linewidth='0.5', color='white') plt.subplots_adjust(left=0.16, bottom=None, right=0.97, top=None, wspace=None, hspace=None) # plt.title('At '+str(round(time/1.0e-15,2))+' fs',fontdict=font) fig = plt.gcf() fig.set_size_inches(20, 10.5) fig.savefig(to_path+'3d_'+name+str(n).zfill(4)+'.png',format='png',dpi=160) plt.close("all") print('finised '+str(n).zfill(4))
import sdf import numpy as np import constant as const from mayavi import mlab data = sdf.read('Documents/data/2800.sdf', dict=True) var1 = data['Electric Field/Ey'].data bz = var1 k_bz = np.fft.fft(bz, axis=0) delta_k = 3.14 / const.delta_x / (const.Nx / 2) k_bz2 = k_bz * 1 k_n = [] for n in range(0, const.Nx): mi = 3e8 / 0.1e12 #limit_min ma = 3e8 / 10e12 #limit_max if 2 * 3.14 / ma > n * delta_k and n * delta_k > 2 * 3.14 / mi: k_n.append(n) k_bz2[0:k_n[0], :, :] = 0 #k_bz.argmin() k_bz2[k_n[-1]:-k_n[-1], :, :] = 0 #k_bz.argmin() k_bz2[-k_n[0]:, :, :] = 0 #k_bz.argmin() var1 = np.fft.ifft(k_bz2, axis=0).real mlab.contour3d(var1) mlab.show()
import sys import sdf import matplotlib.pyplot as plt import os import re a = r'^tp\d{4}.sdf$' for root, dirs, files in os.walk(os.getcwd()): print(files) '''above read file''' for filename in files: if (re.match(a, filename)): ff = sdf.read(filename) '''read sdf''' keys = ff.__dict__.keys() print(keys) print('Next--------------') dataname = r'^\w+_Gamma_\w+$' for key in keys: if (re.match(dataname, key)): print(key) data = ff.__dict__[key]
'size' : 20, } ######### Parameter you should set ########### start = 1 # start time stop = 400 # end time step = 1 # the interval or step Data = 'Data0/' name = 'electron scattering plot' amplitude = '250' ######### Script code drawing figure ################ data0 = sdf.read("./Dataa"+amplitude+"no/0000.sdf",dict=True) #data1 = sdf.read("./Dataa350rr/"+str(n).zfill(4)+".sdf",dict=True) header=data0['Header'] time=header['time'] x0 = data0['Grid/Particles/electron'].data[0]/1.0e-6 y0 = data0['Grid/Particles/electron'].data[1]/1.0e-6 id0 = data0['Particles/ID/electron'].data pos0= np.zeros(5000) print(np.max(id0-1),np.min(id0-1),x0[id0-1]) for i in range(5000): pos0[id0[i]-1]=y0[i] data0 = sdf.read("./Dataa"+amplitude+"rr/0000.sdf",dict=True) #data1 = sdf.read("./Dataa350rr/"+str(n).zfill(4)+".sdf",dict=True) header=data0['Header'] time=header['time']
def use_sdf(sdf_num, pathname, *args, **kwargs): """The basic routine for taking data from an sdf file and putting it in [dat]. The varaibles are put into lists depending on type so they can be easily plotted later, the lists are cleaned of certain variables that cannot easily be plotted. Finally the data is labelled with new units and passed to the analysis functions for post-processing. """ istart = kwargs.get('istart', 0) use_analysis = kwargs.get('use_analysis', False) SDFName=pathname+'/'+str(sdf_num).zfill(4)+'.sdf' dat = sdf.read(SDFName) # Get all variables dat_names = list(dat.__dict__.keys()) variable_type = sdf.BlockPlainVariable grid_type = sdf.BlockLagrangianMesh beam_type = sdf.BlockStitchedPath # Create lists of certain types of variable for plotting dat_grid_names = [] dat_variable_names = [] dat_variable_time_names = [] dat_track_surfaces = [] dat_beam_names = [] dat_burst_names = [] for n in range(0, len(dat_names)): var = getattr(dat, dat_names[n]) if type(var) == variable_type: dat_variable_names.append(dat_names[n]) elif type(var) == grid_type: dat_grid_names.append(dat_names[n]) elif type(var) == beam_type: dat_beam_names.append(dat_names[n]) # Clean grid list of things that require special effort to plot bad_var_list = [] for var in dat_grid_names: if ('Ray' in var): bad_var_list.append(var) if ('Electrons_Electron' in var): bad_var_list.append(var) for var in bad_var_list: dat_grid_names.remove(var) # Clean variable list of things that require special effort to plot bad_var_list = [] for var in dat_variable_names: if ('Ray' in var): bad_var_list.append(var) if ('Electrons_Electron' in var): bad_var_list.append(var) for var in bad_var_list: dat_variable_names.remove(var) # Clean beams list of individual rays bad_var_list = [] for var in dat_beam_names: if ('_' in var): bad_var_list.append(var) else: if ('Burst' in var): dat_burst_names.append(var) bad_var_list.append(var) for var in bad_var_list: dat_beam_names.remove(var) # Clean Epoch list of CPU and particle distributions that I cannot plot yet if (dat.Header['code_name'] == 'Epoch2d'): dat_grid_names = ['Grid_Grid', 'Grid_Grid_mid'] bad_var_list = [] for var in dat_variable_names: if ('CPU' in var): bad_var_list.append(var) if ('dist' in var): bad_var_list.append(var) for var in bad_var_list: dat_variable_names.remove(var) # Add lists to dat setattr(dat, "grids", dat_grid_names) setattr(dat, "track_surfaces", dat_track_surfaces) setattr(dat, "variables", dat_variable_names) setattr(dat, "variables_time", dat_variable_time_names) setattr(dat, "beams", dat_beam_names) setattr(dat, "bursts", dat_burst_names) # Save time variable var_list = dat.variables_time var_name = "Times" var_list.append(var_name) setattr(dat, var_name, afunc.new_variable(data = dat.Header["time"], units_new = "ns", unit_conversion = 1.0e9, name = "Time")) setattr(dat, "variables_time", var_list) dat = add_label(dat) # Analysis functions are applied to SDF data if use_analysis: dat = afunc.basic(dat) if ("Fluid_Energy_deposited_laser" in dat.variables and hasattr(dat, "Fluid_Number_density_electron")): dat = afunc.laser(dat, call_basic = False, laser_change = True, sdf_num = sdf_num, istart = istart, pathname = pathname) if "Fluid_Energy_deposited_hot_electron" in dat.variables: dat = afunc.hot_electron(dat, sdf_num = sdf_num, istart = istart, pathname = pathname) dat = afunc.adiabat(dat, call_basic = False) dat = afunc.energy(dat, call_basic = False) return dat
def main(from_path, to_path): for n in range(start,stop+step,step): if n < 40: x_min,x_max=45,55 y_min,y_max=500,1100 elif n < 50: x_min,x_max=45,55 y_min,y_max=0,1100 elif n < 70: x_min,x_max=45,55 y_min,y_max=-600,1100 elif n < 90: x_min,x_max=40,60 y_min,y_max=-1000,1100 elif n < 125: x_min,x_max=40,60 y_min,y_max=-1000,1100 elif n < 180: x_min,x_max=35,65 y_min,y_max=-1000,1100 elif n < 235: x_min,x_max=30,70 y_min,y_max=-400,400 elif n < 290: x_min,x_max=25,75 y_min,y_max=-400,400 else: x_min,x_max=25-(n*1.0-290.0)*0.1,75+(n*1.0-290.0)*0.1 y_min,y_max=-300,300 #plt.xlim(x_min,x_max) #plt.ylim(y_min,y_max) datalaser = sdf.read("./Datalaser/"+str(n).zfill(4)+".sdf",dict=True) laser_x = datalaser['Grid/Grid_mid'].data[0]/1.0e-6 laser_y = datalaser['Grid/Grid_mid'].data[1]/1.0e-6 X,Y = np.meshgrid(laser_x,laser_y) ex = datalaser['Electric Field/Ey'].data/exunit/250.0 if np.min(ex.T) == np.max(ex.T): continue eee=np.max([-np.min(ex.T),np.max(ex.T)]) levels = np.linspace(-eee, eee, 24) #### header data #### plt.subplots_adjust(left=0.05,right=0.9,bottom=0.1,top=0.95,wspace=0.15,hspace=0.2) plt.subplot(1,3,1) data0 = sdf.read("./Dataa"+amplitude+"no/"+str(n).zfill(4)+".sdf",dict=True) #data1 = sdf.read("./Dataa350rr/"+str(n).zfill(4)+".sdf",dict=True) header=data0['Header'] time=header['time'] x0 = data0['Grid/Particles/electron'].data[0]/1.0e-6 y0 = data0['Grid/Particles/electron'].data[1]/1.0e-6 px0 = data0['Particles/Px/electron'].data/(m0*v0) id0 = data0['Particles/ID/electron'].data # x = data0['Grid/Grid_mid'].data[0]/1.0e-6 # y = data0['Grid/Grid_mid'].data[1]/1.0e-6 # X,Y = np.meshgrid(x,y) # ex = data0['Electric Field/Ey'].data/exunit # if np.min(ex.T) == np.max(ex.T): # continue # eee=np.max([-np.min(ex.T),np.max(ex.T)]) # levels = np.linspace(-eee, eee, 24) # plt.contourf(X, Y, ex.T, levels=levels, cmap=cm.RdGy) plt.scatter(x0,px0,s=20,c=abs(pos0[id0-1]),cmap=cm.rainbow,label='No RR',edgecolors='None') plt.legend(loc='upper right',framealpha=1.0,markerscale=2,fontsize=20.0) plt.xlim(40,90) plt.ylim(-50,1100) #plt.text(x_min+0.1*(x_max-x_min),y_max-0.1*(y_max-y_min),r'$\xi_0$='+amplitude+' No RR',fontsize=25) plt.xlabel('X [$\mu m$]',fontdict=font) plt.ylabel('Px [$m_ec$]',fontdict=font) plt.xticks(fontsize=20); plt.yticks(fontsize=12); plt.title(name+' at '+str(round(time/3.333e-15,2))+' $T_0$',fontdict=font) plt.subplot(1,3,2) data0 = sdf.read("./Dataa"+amplitude+"rr/"+str(n).zfill(4)+".sdf",dict=True) # data1 = sdf.read("./epoch2drr/Data1/"+str(n).zfill(4)+".sdf",dict=True) # data2 = sdf.read("./epoch2dqe/Data1/"+str(n).zfill(4)+".sdf",dict=True) header=data0['Header'] time=header['time'] x0 = data0['Grid/Particles/electron'].data[0]/1.0e-6 y0 = data0['Grid/Particles/electron'].data[1]/1.0e-6 px0 = data0['Particles/Px/electron'].data/(m0*v0) id0 = data0['Particles/ID/electron'].data # plt.scatter(x1,y1,s=8,c=(0,192.0/255.0,0),label='LL RR',edgecolors='None') #plt.contourf(X, Y, ex.T, levels=levels, cmap=cm.bwr) plt.scatter(x0,px0,s=20,c=abs(pos1[id0-1]),cmap=cm.rainbow,label='LL RR',edgecolors='None') plt.legend(loc='upper right',framealpha=1.0,markerscale=2,fontsize=20.0) plt.xlim(40,90) plt.ylim(-50,1100) #plt.text(x_min+0.1*(x_max-x_min),y_max-0.1*(y_max-y_min),r'$\xi_0$='+amplitude+' LL RR',fontsize=25) #plt.text(5,45,r'$\xi_0=350$',fontsize=20) plt.xlabel('X [$\mu m$]',fontdict=font) plt.ylabel('Px [$m_ec$]',fontdict=font) plt.xticks(fontsize=20); plt.yticks(fontsize=12); plt.title(name+' at '+str(round(time/3.333e-15,2))+' $T_0$',fontdict=font) plt.subplot(1,3,3) data0 = sdf.read("./Dataa"+amplitude+"qe/"+str(n).zfill(4)+".sdf",dict=True) header=data0['Header'] time=header['time'] x0 = data0['Grid/Particles/electron'].data[0]/1.0e-6 y0 = data0['Grid/Particles/electron'].data[1]/1.0e-6 px0 = data0['Particles/Px/electron'].data/(m0*v0) id0 = data0['Particles/ID/electron'].data # plt.scatter(x1,y1,s=8,c=(0,192.0/255.0,0),label='LL RR',edgecolors='None') #plt.contourf(X, Y, ex.T, levels=levels, cmap=cm.bwr) plt.scatter(x0,px0,s=20,c=abs(pos2[id0-1]),cmap=cm.rainbow,label='QED RR',edgecolors='None') plt.legend(loc='upper right',framealpha=1.0,markerscale=2,fontsize=20.0) #plt.text(x_min+0.1*(x_max-x_min),y_max-0.1*(y_max-y_min),r'$\xi_0$='+amplitude+' QED RR',fontsize=25) plt.xlim(40,90) plt.ylim(-50,1100) #plt.text(5,45,r'$\xi_0=350$',fontsize=20) plt.xlabel('X [$\mu m$]',fontdict=font) plt.ylabel('Px [$m_ec$]',fontdict=font) plt.xticks(fontsize=20); plt.yticks(fontsize=12); plt.title(name+' at '+str(round(time/3.333e-15,2))+' $T_0$',fontdict=font) #plt.subplots_adjust(left=0.05,right=0.85,bottom=0.1,top=0.95,wspace=0.15,hspace=0.2) cbar=plt.colorbar(ticks=[0.5, 1.0, 1.5, 2.0],cax=plt.axes([0.94,0.1,0.01,0.85])) cbar.set_label('Initial transverse position $y_0$',fontdict=font) fig = plt.gcf() fig.set_size_inches(33, 9) fig.savefig('./jpg_x_px250/gif'+str(n).zfill(4)+'.png',format='png',dpi=45) plt.close("all") fig.show() print 'finised '+str(round(100.0*(n-start+step)/(stop-start+step),4))+'%'
font = { 'family': 'monospace', 'style': 'normal', 'color': 'black', 'weight': 'normal', 'size': 30, } ######### Parameter you should set ########### start = 12 # start time stop = 12 # end time step = 1 # the interval or step n = 12 for n in range(start, stop + step, step): data = sdf.read("./Data_a20_fine/" + str(n).zfill(4) + ".sdf", dict=True) header = data['Header'] time = header['time'] work_x = data[ 'Particles/Time_Integrated_Work_x/subset_high_e/electron'].data work_y = data[ 'Particles/Time_Integrated_Work_y/subset_high_e/electron'].data px = data['Particles/Px/subset_high_e/electron'].data / (m0 * v0) py = data['Particles/Py/subset_high_e/electron'].data / (m0 * v0) grid_x = data['Grid/Particles/subset_high_e/electron'].data[0] / wavelength grid_y = data['Grid/Particles/subset_high_e/electron'].data[1] / wavelength gg = (px**2 + py**2 + 1.0)**0.5 # relativistic factor gamma work_x = work_x[gg > 5] work_y = work_y[gg > 5]
y_y * 100, width, bottom=y_x * 100, color='deepskyblue', edgecolor='black', linewidth=1) if __name__ == "__main__": ######### Script code drawing figure ################ n = 18 mass = 1836. name = 'proton' plt.subplot(1, 1, 1) data = sdf.read('./PW_w010/' + str(n).zfill(4) + ".sdf", dict=True) time = data['Header']['time'] px = data['Particles/Px/' + name].data / (mass * m0 * v0) py = data['Particles/Py/' + name].data / (mass * m0 * v0) grid_y = data['Grid/Particles/' + name].data[1] / 1e-6 gg = (px**2 + py**2 + 1.0)**0.5 ek = (gg - 1.) * mass * m0 * v0**2 / 1.6e-13 ww = data['Particles/Weight/' + name].data * 4e-6 theta = np.arctan2(py, px) * 180.0 / np.pi ek = ek[(px > 0) & (abs(grid_y) < 2) & (abs(theta) < 30)] ww = ww[(px > 0) & (abs(grid_y) < 2) & (abs(theta) < 30)] dist_x1, den1 = pxpy_to_energy(ek, ww) plt.plot(dist_x1, den1, color='crimson', linewidth=3,
def make_patch_spines_invisible(ax): ax.set_frame_on(True) ax.patch.set_visible(False) for sp in ax.spines.values(): sp.set_visible(False) if __name__ == '__main__': start = 10 # start time stop = 27 # end time step = 1 # the interval or step from_path = './cannon_a190_v484/' to_path = './cannon_a190_v484_fig/' data = sdf.read(from_path + "i_tot_loc0027.sdf", dict=True) #grid_x = data['Grid/Particles/subset_high_e/electron'].data[0]/wavelength px = data['Particles/Px/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) py = data['Particles/Py/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) pz = data['Particles/Pz/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) theta = np.arctan2((py**2 + pz**2)**0.5, px) * 180.0 / np.pi gg = (px**2 + py**2 + pz**2 + 1)**0.5 Ek = (gg - 1) * 1836 * 0.51 part13_id = data['Particles/ID/subset_Only_Ions0/Ion'].data part13_id = part13_id[(Ek > 225) & (abs(theta) < 10) & (Ek < 245)] print('part13_id size is ', part13_id.size, ' max ', np.max(part13_id), ' min ', np.min(part13_id)) fig, ax = plt.subplots()
def main(): config_file = parse_input() config = loadconfig(config_file) try: sdf_data = sdf.read(config['sdf_file']) except: raise dirname = os.path.basename(os.getcwd()) grids = {'xgrid':None ,'ygrid':None ,'xbins':None ,'ybins':None} for grid in grids: try: grids[grid] = float(config[grid]) except: pass if ((grids['xgrid'] is not None and grids['xbins'] is not None) or (grids['ygrid'] is not None and grids['ybins'] is not None)): print("Both gridsize and numbins are specified... " "gridsize will take precedence") if ((grids['xgrid'] is None and grids['xbins'] is None) or (grids['ygrid'] is None and grids['ybins'] is None)): print("Warning no gridsize or numbins specified, defaulting to" "100 bins") if grids['xbins'] is None: grids['xbins'] = 100 if grids['ybins'] is None: grids['ybins'] = 100 try: output_name = config['output_name'] except: output_name = 'out' try: output_path = config['output_path'] except: output_path = '.' ell = {'center':None, 'width':None, 'height':None} for arg in ell: try: ell[arg] = float(config['ell_{}'.format(arg)]) except: pass cutoff_px = float(config['cutoff_px']) * sc.m_e * sc.c sdf_e_px = getattr(sdf_data, 'Particles_Px_electron').data sdf_e_x = getattr(sdf_data, 'Grid_Particles_electron').data[0] sdf_e_y = getattr(sdf_data, 'Grid_Particles_electron').data[1] sdf_e_w = getattr(sdf_data, 'Particles_Weight_electron').data sdf_gridx = getattr(sdf_data, 'Grid_Grid').data[0] sdf_gridy = getattr(sdf_data, 'Grid_Grid').data[1] sdf_dens = getattr(sdf_data, 'Derived_Number_Density_electron').data try: sdf_gridz = getattr(sdf_data, 'Grid_Grid').data[2] sdf_e_z = getattr(sdf_data, 'Grid_Particles_electron').data[2] is3d = True except: is3d = False limits = {'xmin':sdf_e_x.min() ,'xmax':sdf_e_x.max() ,'ymin':sdf_e_y.min() ,'ymax':sdf_e_y.max()} if is3d: limits['zmin'] = sdf_e_z.min() limits['zmax'] = sdf_e_z.max() for limit in limits: try: limits[limit] = float(config[limit]) except: pass hist_limits = {} for limit in limits: try: hist_limits[limit] = float(config['hist_'+limit]) except: hist_limits[limit] = limits[limit] xargmin = np.argmin(np.abs(sdf_gridx - limits['xmin'])) xargmax = np.argmin(np.abs(sdf_gridx - limits['xmax'])) yargmin = np.argmin(np.abs(sdf_gridy - limits['ymin'])) yargmax = np.argmin(np.abs(sdf_gridy - limits['ymax'])) if is3d: zargmin = np.argmin(np.abs(sdf_gridz - limits['zmin'])) zargmax = np.argmin(np.abs(sdf_gridz - limits['zmax'])) sdf_gridx = sdf_gridx[xargmin:xargmax] sdf_gridy = sdf_gridy[yargmin:yargmax] sdf_dens = sdf_dens[xargmin:xargmax,yargmin:yargmax] if is3d: sdf_gridz = sdf_gridz[zargmin:zargmax] ### Electron selection magic happens here energy_mask = sdf_e_px > cutoff_px position_mask = np.full(sdf_e_px.shape, True, dtype=bool) if None not in ell.values(): if is3d: position_mask = ( ((sdf_e_x - ell['center'])**2 / (0.25*ell['width']**2)) + (sdf_e_y**2 / (0.25*ell['height']**2)) + (sdf_e_z**2 / (0.25*ell['height']**2)) < 1 ) else: position_mask = ( ((sdf_e_x - ell['center'])**2 / (0.25*ell['width']**2)) + (sdf_e_y**2 / (0.25*ell['height']**2)) < 1 ) bunch_electron_mask = np.where(np.logical_and(energy_mask, position_mask)) bunch_electron_x = sdf_e_x[bunch_electron_mask].reshape(-1) bunch_electron_y = sdf_e_y[bunch_electron_mask].reshape(-1) bunch_electron_w = sdf_e_w[bunch_electron_mask].reshape(-1) if is3d: bunch_electron_z = sdf_e_z[bunch_electron_mask].reshape(-1) if grids['xgrid'] is not None: xbins = np.arange(hist_limits['xmin'],hist_limits['xmax']+grids['xgrid'],grids['xgrid']) else: xbins = np.linspace(hist_limits['xmin'],hist_limits['xmax'],grids['xbins']) if grids['ygrid'] is not None: if hist_limits['ymin'] * hist_limits['ymax'] < 0: ybins = np.sort(np.concatenate(( np.arange(0,hist_limits['ymin']-grids['ygrid'],-grids['ygrid']), np.arange(grids['ymin'],hist_limits['ymax']+grids['ygrid'],grids['ygrid'])))) else: ybins = np.arange(hist_limits['ymin'],hist_limits['ymax']+grids['ygrid'],grids['ygrid']) else: if hist_limits['ymin'] * hist_limits['ymax'] < 0: ybins = np.sort(np.concatenate(( np.linspace(hist_limits['ymin'],0,grids['ybins']//2), np.linspace(0,hist_limits['ymax'],grids['ybins']//2)[1:]))) else: ybins = np.linspace(hist_limits['ymin'],hist_limits['ymax'],grids['ybins']) limlist = [ limits[l]*1e6 for l in ['xmin','xmax','ymin','ymax'] ] hist_limlist = [ hist_limits[l]*1e6 for l in ['xmin','xmax','ymin','ymax'] ] ### Debug Plot #### fig = mf.Figure(figsize=(8.3,11.7)) canvas = mplbea.FigureCanvasAgg(fig) ax = fig.add_subplot(221) ax.imshow(sdf_dens.T ,aspect='auto' ,extent=limlist ,origin='upper' ,norm=LogNorm(1e23,1e26) ,cmap=mcm.plasma) if None not in ell.values(): ax.add_patch(mpat.Ellipse((ell['center']*1e6,0) ,ell['width']*1e6 ,ell['height']*1e6 ,fill=True ,fc='blue' ,alpha=0.2)) ax2 = fig.add_subplot(222) counts, xedges, yedges = np.histogram2d(bunch_electron_x ,bunch_electron_y ,bins=[xbins,ybins] ,weights=bunch_electron_w) areas = np.outer(np.diff(xedges),np.diff(yedges)) hist_dens = counts / areas print("max(dens): {}".format(sdf_dens.max())) print("max(hist): {}".format(hist_dens.max())) ax2.imshow(hist_dens.T ,aspect='auto' ,extent=limlist ,origin='upper' ,norm=LogNorm(1e23,1e26) ,cmap=mcm.plasma) ax3 = fig.add_subplot(223) zcounts = ax3.hist(bunch_electron_x*1e6 ,bins=xbins*1e6 ,weights=bunch_electron_w*sc.e # ,log=True )[0] ax3.set_xlim(limits['xmin']*1e6,limits['xmax']*1e6) # ax3.set_ylim(1e11,5e12) ax3.set_xlabel(r'$z\ \mathrm{(\mu m)}$') ax3.set_ylabel(r'$\mathrm{d}Q\ \mathrm{(C m^{-3})}$') ax.xaxis.set_major_locator(mt.MaxNLocator(5)) ax4 = fig.add_subplot(224) ycounts = ax4.hist(bunch_electron_y*1e6 ,bins=ybins*1e6 ,weights=bunch_electron_w*sc.e )[0] ax4.set_xlim(limits['ymin']*1e6,limits['ymax']*1e6) # ax3.set_ylim(1e11,5e12) ax4.set_xlabel(r'$z\ \mathrm{(\mu m)}$') ax4.set_ylabel(r'$\mathrm{d}Q\ \mathrm{(C m^{-3})}$') xcentres = xedges[:-1] + np.diff(xedges) ycentres = yedges[:-1] + np.diff(yedges) xm, ym = np.meshgrid(xcentres, ycentres, indexing='ij') nz = xcentres[np.where(zcounts > zcounts.max()/np.e)] ax3.axvline(nz.min()*1e6,alpha=0.5) ax3.axvline(nz.max()*1e6,alpha=0.5) bunch_length = nz.max() - nz.min() print("Bunch Length: {}".format(bunch_length)) nz = ycentres[np.where(ycounts > ycounts.max()/2)] ax4.axvline(nz.min()*1e6,alpha=0.5) ax4.axvline(nz.max()*1e6,alpha=0.5) bunch_width = nz.max() - nz.min() print("Bunch Width: {}".format(bunch_width)) x_avg = np.average(bunch_electron_x, weights=bunch_electron_w) x_vari = np.average((bunch_electron_x - x_avg)**2, weights=bunch_electron_w) x_stdev = np.sqrt(x_vari) print("Bunch stdev: {}".format(x_stdev)) unscaled_charge = np.sum(counts*sc.e) bunch_charge_rad = np.sum(np.pi*np.abs(ym)*counts*sc.e) bunch_charge_dep = np.sum(bunch_width*counts*sc.e) print("Total charge(rad): {}".format(bunch_charge_rad)) print("Total charge(depth): {}".format(bunch_charge_dep)) print("Unscaled charge: {}".format(unscaled_charge)) ax3.text(0.10,0.95,r'$Q_w = {:.3}\ \mathrm{{\mu C/m}}$'.format(unscaled_charge*1e6) ,transform=ax3.transAxes ) ax3.text(0.10,0.90,r'$Q_w = {:.3}\ \mathrm{{pC}}$'.format(bunch_charge_dep*1e12) ,transform=ax3.transAxes ) ax3.text(0.10,0.85,r'$Q_r = {:.3}\ \mathrm{{pC}}$'.format(bunch_charge_rad*1e12) ,transform=ax3.transAxes ) ax4.text(0.55,0.90,r'$W_b = {:.3}\ \mathrm{{\mu m}}$'.format(bunch_width*1e6) ,transform=ax4.transAxes ) ax4.text(0.55,0.85,r'$L_b = {:.3}\ \mathrm{{\mu m}}$'.format(bunch_length*1e6) ,transform=ax4.transAxes ) ax4.text(0.55,0.80,r'$\sigma_x = {:.3}\ \mathrm{{\mu m}}$'.format(x_stdev*1e6) ,transform=ax4.transAxes ) fig.savefig('{}/{}_debug_fwhm.png'.format(output_path,output_name)) ### Publication Plot ax1loc =[0.09,0.15,0.37,0.625] ax2loc =[0.59,0.15,0.37,0.625] ax1cbloc =[0.09,0.8,0.37,0.05] ax2cbloc =[0.59,0.8,0.37,0.05] ax1norm=LogNorm(1e23,1e26) ax2norm = LogNorm(1,100) if is3d: plot_dens = sdf_dens[:,:,int(0.5*sdf_dens.shape[3])] else: plot_dens = sdf_dens mpl.rcParams.update({'font.size': 8}) fig = mf.Figure(figsize=(3.2,2)) canvas = mplbea.FigureCanvasAgg(fig) ax = fig.add_axes(ax1loc) ax.imshow(plot_dens.T ,aspect='auto' ,extent=limlist ,origin='upper' ,norm=ax1norm ,cmap=mcm.plasma) ax1cba = fig.add_axes(ax1cbloc) ax1cb = mplcb.ColorbarBase(ax1cba ,cmap=mcm.plasma ,norm=ax1norm ,orientation='horizontal') ax1cba.tick_params(top=True,labelbottom=False,labeltop=True,pad=-1) ax1cb.set_ticks((ax1norm.vmin,ax1norm.vmax)) ax1cba.xaxis.set_label_position('top') ax1cb.set_label(r"$n_e\ \mathrm{m^{-3}}$", labelpad=-4) ax.xaxis.set_major_locator(mt.LinearLocator(3)) ax.yaxis.set_major_locator(mt.LinearLocator(3)) ax.set_xlabel(r'$z\ \mathrm{(\mu m)}$', labelpad=0) ax.set_ylabel(r'$y \mathrm{(\mu m)}$', labelpad=-8) ax2 = fig.add_axes(ax2loc) counts, xbins, patches = ax2.hist(bunch_electron_x*1e6 ,bins=xbins*1e6 ,weights=bunch_electron_w*sc.e*1e9 ,linewidth=0 ) for count, patch in zip(counts,patches): patch.set_facecolor(mcm.plasma(ax2norm(count))) ax2cba = fig.add_axes(ax2cbloc) ax2cb = mplcb.ColorbarBase(ax2cba ,cmap=mcm.plasma ,norm=ax2norm ,orientation='horizontal') ax2cba.tick_params(top=True,labelbottom=False,labeltop=True,pad=-1) ax2cb.set_ticks((ax2norm.vmin,ax2norm.vmax)) ax2cba.xaxis.set_label_position('top') ax2cb.set_label(r"$\mathrm{d}Q/\mathrm{d}z\ \mathrm{nC/m}$", labelpad=-4) ax2.set_xlim(*hist_limlist[:2]) ax2.set_ylim(0,ax2norm.vmax) ax2.xaxis.set_major_locator(mt.LinearLocator(3)) ax2.yaxis.set_major_locator(mt.LinearLocator(3)) ax2.set_xlabel(r'$z\ \mathrm{(\mu m)}$',labelpad=0) ax2.set_ylabel(r'$\mathrm{d}Q/\mathrm{d}x\ \mathrm{(nC/m)}$',labelpad=-2) ax2.text(0.05,0.85,'$dQ = {:.3}\mathrm{{\mu C/m}}$'.format(unscaled_charge*1e6) ,transform=ax2.transAxes ) try: fig.text(0.05,0.94,'{}'.format(config['title']) ,transform=fig.transFigure, fontsize=10) except Exception as err: print(err) fig.savefig('{}/{}_pub_fwhm.png'.format(output_path,output_name) ,dpi=300)
name='myColorMap', N=cmap.shape[0]) if __name__ == '__main__': start = 1 # start time stop = 19 # end time step = 1 # the interval or step from_path = './PW_w020/' to_path = './PW_w020_fig/' part_name = 'electron' mass = 1.0 for n in range(start, stop + step, step): data = sdf.read(from_path + str(n).zfill(4) + ".sdf", dict=True) header = data['Header'] time1 = header['time'] px = data['Particles/Px/' + part_name].data / (mass * m0 * v0) py = data['Particles/Py/' + part_name].data / (mass * m0 * v0) work_x = data['Particles/Time_Integrated_Work_x/' + part_name].data * 0.51 work_y = data['Particles/Time_Integrated_Work_y/' + part_name].data * 0.51 gg = (px**2 + py**2 + 1)**0.5 theta = np.arctan2(py, px) * 180.0 / np.pi grid_x = data['Grid/Particles/' + part_name].data[0] / 1.0e-6 grid_y = data['Grid/Particles/' + part_name].data[1] / 1.0e-6 temp_id = data['Particles/ID/' + part_name].data weight = data['Particles/Weight/' + part_name].data * 4e-6
bxunit = m0*frequency/q0 denunit = frequency**2*epsilon0*m0/q0**2 print 'electric field unit: '+str(exunit) print 'magnetic field unit: '+str(bxunit) print 'density unit nc: '+str(denunit) font = {'family' : 'Helvetic', 'color' : 'black', 'weight' : 'normal', 'size' : 16, } plt.rc('text', usetex=True) plt.rc('font', family='serif') data1 = sdf.read("./Datan2w33p/0029.sdf",dict=True) data2 = sdf.read("./Datan5w33p/0029.sdf",dict=True) data3 = sdf.read("./Datan10w33p/0029.sdf",dict=True) data4 = sdf.read("./Datan20w33p/0029.sdf",dict=True) header=data1['Header'] time=header['time'] plt.subplots_adjust(left=0.05,right=0.95,bottom=0.1,top=0.95,wspace=0.25,hspace=0.3) plt.subplot(1,3,1) name='electron' en_Z1 = data1['dist_fn/en/'+name].data[:,0,0] dist_x1 = data1['Grid/en/'+name].data[0]/(q0*1.0e6) en_Z2 = data2['dist_fn/en/'+name].data[:,0,0] dist_x2 = data2['Grid/en/'+name].data[0]/(q0*1.0e6)
#youwant Derived electron_density,electron_ekbar... #youwant dist_fn electron_x_px, electron_py_pz, electron_theta_en... #if (os.path.isdir('jpg') == False): # os.mkdir('jpg') ######### Script code drawing figure ################ n0=30.0 R=1.8e-6 L=15e-6 Ntot = np.pi*R*R*L*n0*denunit V=(1.0/20.0)*(1.0/15.0)*(1.0/15.0)*1.0e-18 weight = V*denunit*n0/20.0 # weight = Ntot/(1200*360*360*50) set_relativistic =1 for n in np.arange(start,stop+step,step): data = sdf.read(from_path+"i_tot_loc"+str(n).zfill(4)+".sdf",dict=True) header=data['Header'] time1=header['time'] if set_relativistic == 1: px = data['Particles/Px/subset_Only_Ions0/Ion'].data/(1836*m0*v0) py = data['Particles/Py/subset_Only_Ions0/Ion'].data/(1836*m0*v0) pz = data['Particles/Pz/subset_Only_Ions0/Ion'].data/(1836*m0*v0) gg = (px**2+py**2+pz**2+1)**0.5 theta = np.arctan2((py**2+pz**2)**0.5,px)*180.0/np.pi ek_1 = (gg - 1.0)*0.51*1836 ww_1 = np.zeros_like(ek_1) + weight dist_x1, den1 = pxpy_to_energy(ek_1,ww_1) ek_2 = (gg[abs(theta)<10.0] - 1.0)*0.51*1836 ww_2 = np.zeros_like(ek_2) + weight
def processplot(n): ######### Parameter you should set ########### #start = 23 # start time #stop = 30 # end time #step = 1 # the interval or step youwant = ['Electron_density','Ion_density','Electron_ekbar','Ion_ekbar','ex','ey','bz','ex_averaged','ez_averaged','by_averaged'] #youwant = ['ey','ex','ey_averaged','bz','bz_averaged'] #,'electron_en','electron_ekbar','electron_density'] #youwant.append('Ion_ekbar') #youwant.append('positron_ekbar') #youwant.append('electron_en') #youwant.append('photon_en') #youwant field ex,ey,ez,bx,by,bz,ex_averaged,bx_averaged... #youwant Derived electron_density,electron_ekbar... #youwant dist_fn electron_x_px... from_path = './cannon_a190_bulk200/' to_path = './cannon_a190_bulk200/' ######### Script code drawing figure ################ #for n in range(start,stop+step,step): #### header data #### #data = sdf.read(from_path+str(n).zfill(4)+".sdf",dict=True) #header=data['Header'] #time=header['time'] #x = data['Grid/Grid_mid'].data[0]/1.0e-6 #y = data['Grid/Grid_mid'].data[1]/1.0e-6 #X, Y = np.meshgrid(x, y) for name in youwant: if (name[0:2] == 'ex') or (name[0:2] == 'ey') or (name[0:2] == 'ez'): data = sdf.read(from_path+'e_fields'+str(n).zfill(4)+".sdf",dict=True) header=data['Header'] time=header['time'] x = data['Grid/Grid_mid'].data[0]/1.0e-6 y = data['Grid/Grid_mid'].data[2]/1.0e-6 X, Y = np.meshgrid(x, y) eexx = data['Electric Field/'+str.capitalize(name)].data/exunit n3d=len(eexx[0,:,0]) ex = (eexx[:,n3d//2-1,:]+eexx[:,n3d//2,:])/2 if np.min(ex.T) == np.max(ex.T): continue eee=np.max([-np.min(ex.T),np.max(ex.T)]) #if (name == 'ex'): # eee = 50 #elif (name == 'ex_averaged'): # eee = 30 #elif (name == 'ey') or (name == 'bz'): # eee = 380 #elif (name == 'ey_averaged') or (name == 'ez_averaged'): # eee = 30 levels = np.linspace(-eee, eee, 40) plt.contourf(X, Y, ex.T, levels=levels, norm=mcolors.Normalize(vmin=-eee, vmax=eee), cmap=cm.jet) #### manifesting colorbar, changing label and axis properties #### cbar=plt.colorbar(ticks=[-eee, -eee/2, 0, eee/2, eee]) cbar.set_label('Normalized electric field',fontdict=font) cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=15) plt.xlabel('X [$\mu m$]',fontdict=font) plt.ylabel('Z [$\mu m$]',fontdict=font) plt.xticks(fontsize=20); plt.yticks(fontsize=20); plt.title(name+' at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) fig = plt.gcf() fig.set_size_inches(12, 7) fig.savefig(to_path+'_c'+name+str(n).zfill(4)+'.png',format='png',dpi=100) plt.close("all") elif (name[0:2] == 'bx') or (name[0:2] == 'by') or (name[0:2] == 'bz'): data = sdf.read(from_path+'b_fields'+str(n).zfill(4)+".sdf",dict=True) header=data['Header'] time=header['time'] x = data['Grid/Grid_mid'].data[0]/1.0e-6 y = data['Grid/Grid_mid'].data[2]/1.0e-6 X, Y = np.meshgrid(x, y) eexx = data['Magnetic Field/'+str.capitalize(name)].data/bxunit n3d=len(eexx[0,:,0]) ex = (eexx[:,n3d//2-1,:]+eexx[:,n3d//2,:])/2 if np.min(ex.T) == np.max(ex.T): continue eee=np.max([-np.min(ex.T),np.max(ex.T)]) #if (name == 'ey') or (name == 'bz'): # eee = 380 #elif (name == 'by_averaged') or (name == 'bz_averaged'): # eee = 30 levels = np.linspace(-eee, eee, 40) plt.contourf(X, Y, ex.T, levels=levels, norm=mcolors.Normalize(vmin=-eee, vmax=eee), cmap=cm.jet) #### manifesting colorbar, changing label and axis properties #### cbar=plt.colorbar(ticks=[-eee, -eee/2, 0, eee/2, eee]) cbar.set_label('Normalized magnetic field',fontdict=font) cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=15) plt.xlabel('X [$\mu m$]',fontdict=font) plt.ylabel('Z [$\mu m$]',fontdict=font) plt.xticks(fontsize=20); plt.yticks(fontsize=20); plt.title(name+' at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) fig = plt.gcf() fig.set_size_inches(12, 7) fig.savefig(to_path+'_c'+name+str(n).zfill(4)+'.png',format='png',dpi=100) plt.close("all") elif (name[-7:] == 'density'): data = sdf.read(from_path+'q'+str(n).zfill(4)+".sdf",dict=True) header=data['Header'] time=header['time'] x = data['Grid/Grid_mid'].data[0]/1.0e-6 y = data['Grid/Grid_mid'].data[2]/1.0e-6 X, Y = np.meshgrid(x, y) ddeen = data['Derived/Number_Density/'+name[0:-8]].data/denunit n3d=len(ddeen[0,:,0]) den = (ddeen[:,n3d//2-1,:]+ddeen[:,n3d//2,:])/2 if np.min(den.T) == np.max(den.T): continue eee=np.max(den.T) #if (name == 'Ion_density'): # eee = 200 #elif (name == 'Electron_density'): # eee = 200 levels = np.logspace(-1, np.log10(eee), 40) plt.contourf(X, Y, den.T, levels=levels,norm=colors.LogNorm(vmin=0.1, vmax=eee), cmap=cm.nipy_spectral) #### manifesting colorbar, changing label and axis properties #### cbar=plt.colorbar(ticks=np.logspace(-1, 2, 4)) cbar.set_label(name+'[$n_c$]', fontdict=font) cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=15) plt.xlabel('X [$\mu m$]',fontdict=font) plt.ylabel('Z [$\mu m$]',fontdict=font) plt.xticks(fontsize=20); plt.yticks(fontsize=20); plt.title(name+' at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) fig = plt.gcf() fig.set_size_inches(12, 7) fig.savefig(to_path+'_c'+name+str(n).zfill(4)+'.png',format='png',dpi=100) plt.close("all") elif (name[-5:] == 'ekbar'): data = sdf.read(from_path+'ekbar'+str(n).zfill(4)+".sdf",dict=True) header=data['Header'] time=header['time'] x = data['Grid/Grid_mid'].data[0]/1.0e-6 y = data['Grid/Grid_mid'].data[2]/1.0e-6 X, Y = np.meshgrid(x, y) ddeen = data['Derived/EkBar_averaged/'+name[0:-6]].data/(q0*1.0e6) n3d=len(ddeen[0,:,:]) den = (ddeen[:,n3d//2-1,:]+ddeen[:,n3d//2,:])/2 if np.min(den.T) == np.max(den.T): continue eee=np.max(den.T) #if (name == 'Ion_ekbar_averaged'): # eee = 400 #elif name == 'Electron_ekbar_averaged': # eee = 800 levels = np.logspace(-1, np.log10(eee), 40) plt.contourf(X, Y, den.T, levels=levels,norm=colors.LogNorm(vmin=0.1, vmax=eee), cmap=cm.nipy_spectral) #### manifesting colorbar, changing label and axis properties #### cbar=plt.colorbar(ticks=np.logspace(-1, 2, 4)) cbar.set_label(name+'[MeV]', fontdict=font) cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=15) plt.xlabel('X [$\mu m$]',fontdict=font) plt.ylabel('Z [$\mu m$]',fontdict=font) plt.xticks(fontsize=20); plt.yticks(fontsize=20); plt.title(name+' at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) fig = plt.gcf() fig.set_size_inches(12, 7) fig.savefig(to_path+'_c'+name+str(n).zfill(4)+'.png',format='png',dpi=100) plt.close("all") elif (name[-4:] == 'x_px'): data = sdf.read(from_path+'dist'+str(n).zfill(4)+".sdf",dict=True) header=data['Header'] time=header['time'] den = data['dist_fn/x_px/'+name[0:-5]].data[:,:,0] den = np.log(den+1.0) if np.min(den.T) == np.max(den.T): continue levels = np.linspace(np.min(den.T), np.max(den.T), 40) dist_x = data['Grid/x_px/'+name[0:-5]].data[0]/1.0e-6 dist_y = data['Grid/x_px/'+name[0:-5]].data[1]/(m0*v0) dist_X, dist_Y = np.meshgrid(dist_x, dist_y) plt.contourf(dist_X, dist_Y, den.T, levels=levels, cmap=cm.nipy_spectral) #### manifesting colorbar, changing label and axis properties #### cbar=plt.colorbar(ticks=np.linspace(np.min(den.T), np.max(den.T), 5)) cbar.set_label(name+'[$log_{10}(A.U.)$]', fontdict=font) plt.xlabel('X [$\mu m$]',fontdict=font) plt.ylabel('$P_x$ [$m_ec$]',fontdict=font) plt.xticks(fontsize=20); plt.yticks(fontsize=20); plt.title(name+' at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) fig = plt.gcf() fig.set_size_inches(12, 7) fig.savefig(to_path+'_c'+name+str(n).zfill(4)+'.png',format='png',dpi=100) plt.close("all") elif (name[-8:] == 'theta_en'): denden = data['dist_fn/theta_en/'+name[0:-9]].data[:,:,0] den = np.log(denden+1.0) if np.min(den.T) == np.max(den.T): continue levels = np.linspace(np.min(den.T), np.max(den.T), 40) dist_x = data['Grid/theta_en/'+name[0:-9]].data[0] dist_y = data['Grid/theta_en/'+name[0:-9]].data[1]/(q0*1.0e6) dist_X, dist_Y = np.meshgrid(dist_x, dist_y) plt.contourf(dist_X, dist_Y, den.T, levels=levels, cmap=cm.nipy_spectral) #### manifesting colorbar, changing label and axis properties #### cbar=plt.colorbar(ticks=np.linspace(np.min(den.T), np.max(den.T), 5)) cbar.set_label(name+'[$log_{10}(A.U.)$]', fontdict=font) plt.xlabel('$\Psi$ [rad]',fontdict=font) plt.ylabel('$Energy$ [MeV]',fontdict=font) plt.xticks(fontsize=20); plt.yticks(fontsize=20); plt.title(name+' at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) plt1 = plt.twinx() plt1.plot(dist_x,np.sum(denden,axis=1),'-y',linewidth=2.5) #plt1.set_ylabel('Normalized '+name) fig = plt.gcf() fig.set_size_inches(12, 7) fig.savefig(to_path+'_c'+name+str(n).zfill(4)+'.png',format='png',dpi=100) plt.close("all") elif (name[-2:] == 'en'): data = sdf.read(from_path+'dist'+str(n).zfill(4)+".sdf",dict=True) header=data['Header'] time=header['time'] den = data['dist_fn/en/'+name[0:-3]].data[:,0,0] dist_x = data['Grid/en/'+name[0:-3]].data[0]/(q0*1.0e6) plt.plot(dist_x,den,'-r',linewidth=3) #### manifesting colorbar, changing label and axis properties #### plt.xlabel('Energy [MeV]',fontdict=font) plt.ylabel('dN/dE [A.U.]',fontdict=font) plt.xticks(fontsize=20); plt.yticks(fontsize=20); plt.yscale('log') plt.title(name+' at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) fig = plt.gcf() fig.set_size_inches(12, 7) fig.savefig(to_path+'_c'+name+str(n).zfill(4)+'.png',format='png',dpi=100) plt.close("all") print('finised '+str(round(100.0*(n-start+step)/(stop-start+step),4))+'%') return 0
def processplot(n): ######### Parameter you should set ########### #start = 210 # start time #stop = 210 # end time #step = 1 # the interval or step # youwant = ['electron_x_px','electron_density','electron_en','electron_theta_en','ey'] #,'electron_ekbar'] #youwant field ex,ey,ez,bx,by,bz,ex_averaged,bx_averaged... #youwant Derived electron_density,electron_ekbar... #youwant dist_fn electron_x_px, electron_py_pz, electron_theta_en... #if (os.path.isdir('jpg') == False): # os.mkdir('jpg') #from_path = './uniform_a190_n30/' from_path = './cannon_a190/' to_path = from_path ######### Script code drawing figure ################ #for n in range(start,stop+step,step): #### header data #### data = sdf.read(from_path+'q'+str(n).zfill(4)+".sdf",dict=True) header=data['Header'] time=header['time'] x = data['Grid/Grid_mid'].data[0]/1.0e-6 print('ok') y = data['Grid/Grid_mid'].data[1]/1.0e-6 X, Y = np.meshgrid(x, y) den = data['Derived/Number_Density/Electron'].data/denunit n3d = len(den[0,0,:]) den = (den[:,:,n3d//2-1]+den[:,:,n3d//2])/2.0 eee = 50.0 levels = np.linspace(0, eee, 101) den.T[den.T > eee]=eee #gs = gridspec.GridSpec(2, 2, width_ratios=[6, 1], height_ratios=[1, 3]) ax=plt.subplot(1,1,1) #axin1 = inset_axes(ax, width='15%', height='5%', loc='upper left',pad=0.2) #axin2 = inset_axes(ax, width='15%', height='5%', loc='lower left',pad=0.2) #axin1 = inset_axes(ax,width="5%",height="45%",loc='upper right', bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0,) #axin2 = inset_axes(ax,width="5%",height="45%",loc='lower right', bbox_to_anchor=(1.05, 0., 1, 1), bbox_transform=ax.transAxes, borderpad=0,) #### manifesting colorbar, changing label and axis properties #### image1=ax.contourf(X, Y, den.T, levels=levels, norm=mcolors.Normalize(vmin=levels.min(), vmax=levels.max()), cmap='pink_r') cbar=plt.colorbar(image1,ticks=np.linspace(0.0, eee, 5),orientation="vertical") cbar.set_label('$n_e$ [$n_c$]', fontdict=font2) cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=font2['size']) name = 'ey' data = sdf.read(from_path+'e_fields'+str(n).zfill(4)+".sdf",dict=True) ex = data['Electric Field/'+str.capitalize(name)].data/exunit ex = (ex[:,:,n3d//2-1]+ex[:,:,n3d//2])/2.0 eee = 300.0 levels = np.linspace(-eee, eee, 51) ex.T[ex.T < -eee]=-eee ex.T[ex.T > eee]= eee image2=ax.contourf(X, Y, ex.T, levels=levels, cmap=cmap_br) #### manifesting colorbar, changing label and axis properties #### cbar=plt.colorbar(image2,ticks=np.linspace(-eee, eee, 5),orientation="vertical") cbar.set_label(r'$E_y\ [m_ec\omega_0/e]$',fontdict=font2) cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(),fontsize=font2['size']) plt.title('Ey_den_e at '+str(round(time/1.0e-15,6))+' fs',fontdict=font) #ax.text(21.,1.75,'t = '+str(round(time/1.0e-15,0))+' fs',fontdict=font) #ax.text(21.,1.75,'t = 70 fs',fontdict=font) ax.set_ylim(-8.,8.) ax.set_xlim(-5,25) ax.set_xlabel('X [$\lambda$]',fontdict=font) ax.set_ylabel('Y [$\lambda$]',fontdict=font) ax.tick_params(axis='both',labelsize=25) #ax.set_xticklabels(xticklabels,fontdict=font) #ax.set_yticklabels(yticklabels,fontdict=font) # plt.subplot(gs[0]) # plt.scatter(ppp_x[abs(ppp_y)<=3.2],ppp_px[abs(ppp_y)<=3.2],s=10,c='green',edgecolors='None',alpha=0.5) # plt.xlim(0,30) # plt.ylabel('p$_x$ [m$_e$c]', fontdict=font) # plt.xticks([]) # plt.yticks(fontsize=20) # # plt.subplot(gs[3]) # plt.scatter(ppp_py[abs(ppp_y)<=3.2],ppp_y[abs(ppp_y)<=3.2],s=10,c='green',edgecolors='None',alpha=0.5) # plt.ylim(-6.5,6.5) # plt.xlabel('p$_y$ [m$_e$c]', fontdict=font) # plt.yticks([]) # plt.xticks(fontsize=20) # # # plt.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.011, hspace=0.051) # #fig=plt.subplot(gs[1]) #ax1 = fig.add_axes([0.05, 0.85, 0.9, 0.10]) #ax2 = fig.add_axes([0.05, 0.35, 0.9, 0.10]) #cmap = mpl.cm.rainbow #norm = mpl.colors.Normalize(vmin=0.0, vmax=50) #cb1 = mpl.colorbar.ColorbarBase(ax1, cmap='Greys', # norm=norm, # orientation='horizontal',ticks=np.linspace(0.00, 50, 6)) #cb1.set_label('n$_e$ [n$_c$]') #cmap = mpl.colors.ListedColormap(['r', 'g', 'b', 'c']) #cmap.set_over('0.25') #cmap.set_under('0.75') #cmap = mpl.cm.BrBG #Bz = 22.5 #norm = mpl.colors.Normalize(vmin=-abs(Bz), vmax=abs(Bz)) #cb2 = mpl.colorbar.ColorbarBase(ax2, cmap=cmap_br, # norm=norm, # orientation='horizontal',ticks=np.linspace(-abs(Bz), abs(Bz), 5),alpha=0.7) #cb2.set_label(r'E$_y$ [m$_e\omega$/e]') #cmap = mpl.colors.ListedColormap(['r', 'g', 'b', 'c']) #cmap.set_over('0.25') #cmap.set_under('0.75') fig = plt.gcf() fig.set_size_inches(18, 6.) fig.savefig(to_path+'ey_e_density'+str(n).zfill(4)+'.png',format='png',dpi=160) plt.close("all") return 0
if not os.path.exists(to_path): os.mkdir(to_path) n0 = 30.0 # n0=float(dir_n[-2:]) R = 1.8e-6 L = 15e-6 Ntot = np.pi * R * R * L * n0 * denunit V = (1.0 / 20.0) * (1.0 / 15.0) * (1.0 / 15.0) * 1.0e-18 ######### Script code drawing figure ################ for n in range(start, stop + step, step): weight = V * denunit * n0 / 50.0 name = 'ex_averaged' if not os.path.exists(from_path + 'e_fields' + str(n).zfill(4) + ".sdf"): continue data = sdf.read(from_path + 'e_fields' + str(n).zfill(4) + ".sdf", dict=True) header = data['Header'] time = header['time'] x = data['Grid/Grid_mid'].data[0] / 1.0e-6 y = data['Grid/Grid_mid'].data[1] / 1.0e-6 z = data['Grid/Grid_mid'].data[2] / 1.0e-6 X, Y, Z = np.meshgrid(x, y, z, sparse=False, indexing='ij') RR = (Y**2 + Z**2)**0.5 eexx = data['Electric Field/' + str.capitalize(name)].data / exunit eexx = eexx[:, RR[0, :, :] < 1.5] print(eexx.shape) n_size = eexx[-1, :].size ex = np.sum(eexx, axis=1) / n_size np.savetxt(
import sys import sdf import matplotlib.pyplot as plt fname = "Data/0010.sdf" varname = "Electric_Field_Ex" try: d = sdf.read(fname) except: print 'File "%s" not found' % fname sys.exit() if not hasattr(d, varname): print 'Variable "%s" not found in file' % varname sys.exit() var = d.__dict__[varname] if len(var.dims) != 2: print 'File "%s" is not from a 2D run' % fname sys.exit() iy = var.dims[1] / 2 grid = var.grid_mid x = grid.data[0] fig = plt.figure() plt.plot(x, var.data[:, iy], 'r+-') plt.xlabel(grid.labels[0] + r' $(' + grid.units[0] + ')$') plt.ylabel(var.name + r' $(' + var.units + ')$')
def composite_field_plot(varname, vmin=None, vmax=None, directory='Data'): global verbose, dpi file_list = get_files(wkdir=directory) file_list = clean_file_list(file_list, varname) file_list.remove(directory + '00000.sdf') file_list.remove(directory + '00002.sdf') file_list.remove(directory + '00003.sdf') file_list.remove(directory + '00004.sdf') file_list.remove(directory + '00005.sdf') file_list.remove(directory + '00006.sdf') file_list.remove(directory + '00007.sdf') file_list.remove(directory + '00008.sdf') file_list.remove(directory + '00009.sdf') file_list.remove(directory + '00010.sdf') file_list.remove(directory + '00011.sdf') file_list.remove(directory + '00012.sdf') file_list.remove(directory + '00013.sdf') file_list.remove(directory + '00014.sdf') file_list.remove(directory + '00015.sdf') file_list.remove(directory + '00016.sdf') file_list.remove(directory + '00017.sdf') file_list.remove(directory + '00018.sdf') file_list.remove(directory + '00019.sdf') file_list.remove(directory + '00020.sdf') file_list.remove(directory + '00021.sdf') file_list.remove(directory + '00022.sdf') file_list.remove(directory + '00023.sdf') file_list.remove(directory + '00024.sdf') file_list.remove(directory + '00025.sdf') file_list.remove(directory + '00027.sdf') file_list.remove(directory + '00028.sdf') file_list.remove(directory + '00029.sdf') file_list.remove(directory + '00030.sdf') file_list.remove(directory + '00031.sdf') file_list.remove(directory + '00032.sdf') file_list.remove(directory + '00033.sdf') file_list.remove(directory + '00034.sdf') file_list.remove(directory + '00035.sdf') file_list.remove(directory + '00037.sdf') file_list.remove(directory + '00038.sdf') file_list.remove(directory + '00039.sdf') file_list.remove(directory + '00040.sdf') file_list.remove(directory + '00041.sdf') file_list.remove(directory + '00042.sdf') file_list.remove(directory + '00043.sdf') file_list.remove(directory + '00044.sdf') file_list.remove(directory + '00045.sdf') file_list.remove(directory + '00047.sdf') file_list.remove(directory + '00048.sdf') file_list.remove(directory + '00049.sdf') file_list.remove(directory + '00050.sdf') file_list.remove(directory + '00051.sdf') file_list.remove(directory + '00052.sdf') file_list.remove(directory + '00053.sdf') file_list.remove(directory + '00054.sdf') file_list.remove(directory + '00055.sdf') if verbose > 0: print('Found {} files to plot'.format(len(file_list))) data = [] for f in file_list: d = sdf.read(f) var = d.__dict__[varname] data.append(var.data) data = np.asarray(data) data = data.T tmin = sdf.read(file_list[0]).Header['time'] tmax = sdf.read(file_list[-1]).Header['time'] grid = var.grid_mid xmin = np.min(grid.data[0]) xmax = np.max(grid.data[0]) shape = data.shape extent = [tmin, tmax, xmax, xmin] xmult, xsym = get_si_prefix(xmax - xmin) # y axis tmult, tsym = get_si_prefix(tmax - tmin) # x axis if vmin is None and vmax is None: vmin, vmax = get_var_range_from_sdf_files(file_list, varname) elif vmin is None: vmin = get_var_range_from_sdf_files(file_list, varname)[0] elif vmax is None: vmax = get_var_range_from_sdf_files(file_list, varname)[1] mult, sym = get_si_prefix(vmax - vmin) fig, ax = plt.subplots() im = ax.imshow(data, extent=extent, aspect=calculate_aspect(shape, extent), interpolation='none', cmap=cm.plasma, vmin=vmin, vmax=vmax) ax.xaxis.set_major_formatter(FuncFormatter(lambda x, y: (x * tmult))) ax.yaxis.set_major_formatter(FuncFormatter(lambda x, y: (x * xmult))) plt.xlabel('t $(' + tsym + 's)$') plt.ylabel(grid.labels[0] + ' $(' + xsym + grid.units[0] + ')$') # data_label = var.name + ' $(' + sym + var.units + ')$' data_label = 'Argon$^{+8}$ Number Density $(' + sym + var.units + ')$' plt.title('Electron Density Evolution') cbar = fig.colorbar(im, label=data_label, format=FuncFormatter(lambda x, y: x * mult)) plt.tight_layout() plt.savefig('electron_comp_thermal_nocoll.png', dpi=600, bbox_inches="tight")
def main(): dirname = os.path.basename(os.getcwd()) config_file = parse_input() config = loadconfig(config_file) sdf_handles = [] sdf_files = config['sdf_files'] if type(sdf_files) is not type([]): sdf_files = [sdf_files,] for sdf_file in sdf_files: try: sdf_data = sdf.read(sdf_file) except: print("Warning: Failed to open '{}'".format(sdf_file)) else: sdf_handles.append(sdf_data) if len(sdf_handles) < 1: print("Error: Unable to open any sdf files") print("Exiting....") return(-1) #load sdf data (needs to be done before we can sanity check input) sdf_e_px = getattr_from_any(sdf_handles, 'Particles_Px_electron').data sdf_e_x = getattr_from_any(sdf_handles, 'Grid_Particles_electron').data[0] sdf_e_y = getattr_from_any(sdf_handles, 'Grid_Particles_electron').data[1] sdf_e_w = getattr_from_any(sdf_handles, 'Particles_Weight_electron').data sdf_gridx = getattr_from_any(sdf_handles, 'Grid_Grid').data[0] sdf_gridy = getattr_from_any(sdf_handles, 'Grid_Grid').data[1] sdf_dens = getattr_from_any(sdf_handles, 'Derived_Number_Density_electron').data try: sdf_gridz = getattr_from_any(sdf_handles, 'Grid_Grid').data[2] sdf_e_z = getattr_from_any(sdf_handles, 'Grid_Particles_electron').data[2] is3d = True except: is3d = False grids = {'xgrid':None ,'ygrid':None ,'zgrid':None ,'xbins':None ,'ybins':None ,'zbins':None} for grid in grids: try: grids[grid] = float(config[grid]) except: pass if ((grids['xgrid'] is not None and grids['xbins'] is not None) or (grids['ygrid'] is not None and grids['ybins'] is not None) or (grids['zgrid'] is not None and grids['zbins'] is not None)): print("Both gridsize and numbins are specified... " "gridsize will take precedence") if ((grids['xgrid'] is None and grids['xbins'] is None) or (grids['ygrid'] is None and grids['ybins'] is None)): print("Warning no gridsize or numbins specified, defaulting to " "100 bins") if grids['xbins'] is None: grids['xbins'] = 100 if grids['ybins'] is None: grids['ybins'] = 100 if is3d and (grids['zgrid'] is None and grids['zbins'] is None): print("Warning no gridsize or numbins specified, defaulting to " "100 bins") grids['zbins'] = 100 try: output_name = config['output_name'] except: output_name = 'out' try: output_path = config['output_path'] except: output_path = '.' try: pub_xmin = float(config['pub_xmin'])*1e6 except: pub_xmin = None try: pub_xmax = float(config['pub_xmax'])*1e6 except: pub_xmax = None try: pub_ymin = float(config['pub_ymin']) except: pub_ymin = None try: pub_ymax = float(config['pub_ymax']) except: pub_ymax = None reset_origin = False if 'reset_origin' in config: if not 'false'.startswith(config['reset_origin'].lower()): reset_origin = True lineout_inset = False if 'lineout_inset' in config: if not 'false'.startswith(config['lineout_inset'].lower()): lineout_inset = True try: lineout_xmin = float(config['lineout_xmin'])*1e6 except: lineout_xmin = None try: lineout_xmax = float(config['lineout_xmax'])*1e6 except: lineout_xmax = None try: lineout_ymin = float(config['lineout_ymin']) except: lineout_ymin = None try: lineout_ymax = float(config['lineout_ymax']) except: lineout_ymax = None cutoff_px = float(config['cutoff_px']) * sc.m_e * sc.c extents = {'xmin':sdf_e_x.min() ,'xmax':sdf_e_x.max() ,'ymin':sdf_e_y.min() ,'ymax':sdf_e_y.max()} if is3d: extents['zmin'] = sdf_e_z.min() extents['zmax'] = sdf_e_z.max() #parse in spatial limits and sanity check limits = {} for extent in extents: try: limits[extent] = float(config[extent]) except: limits[extent] = extents[extent] if limits['xmax'] < limits['xmin']: limits['xmin'], limits['xmax'] = limits['xmax'], limits['xmin'] if limits['ymax'] < limits['ymin']: limits['ymin'], limits['ymax'] = limits['ymax'], limits['ymin'] if is3d: if limits['zmax'] < limits['zmin']: limits['zmin'], limits['zmax'] = limits['zmax'], limits['zmin'] for extent in limits: if extent.endswith('max'): if limits[extent] > extents[extent]: limits[extent] = extents[extent] print("Warning {} out of range, ignoring".format(extent)) else: if limits[extent] < extents[extent]: limits[extent] = extents[extent] print("Warning {} out of range, ignoring".format(extent)) #parse in ellipse parameters and sanity check ellipse_sane = False ell = {'centerx':None, 'radx':None, 'centery':0.0, 'rady':None} if is3d: ell['centerz'] = 0.0 ell['radz'] = None for arg in ell: try: ell[arg] = float(config['ell_{}'.format(arg)]) except: pass if None not in ell.values(): ellipse_sane = True if ((ell['centerx'] + ell['radx'] < limits['xmin']) or (ell['centerx'] - ell['radx'] > limits['xmax']) or (ell['centery'] + ell['rady'] < limits['ymin']) or (ell['centery'] - ell['rady'] > limits['ymax'])): print("Error, ellipse is entirely outside of view window") return(-1) if ((ell['centerx'] - ell['radx'] < limits['xmin']) or (ell['centerx'] + ell['radx'] > limits['xmax']) or (ell['centery'] - ell['rady'] < limits['ymin']) or (ell['centery'] + ell['rady'] > limits['ymax'])): print("Warning, ellipse is clipped by view window") if is3d: if ((ell['centerz'] + ell['radz'] < limits['zmin']) or (ell['centerz'] - ell['radz'] > limits['zmax'])): print("Error, ellipse is entirely outside of view window") return(-1) if ((ell['centerz'] - ell['radz'] < limits['zmin']) or (ell['centerz'] + ell['radz'] > limits['zmax'])): print("Warning, ellipse is clipped by view window") #trim grid data to specfied limits xargmin = np.argmin(np.abs(sdf_gridx - limits['xmin'])) xargmax = np.argmin(np.abs(sdf_gridx - limits['xmax'])) yargmin = np.argmin(np.abs(sdf_gridy - limits['ymin'])) yargmax = np.argmin(np.abs(sdf_gridy - limits['ymax'])) if is3d: zargmin = np.argmin(np.abs(sdf_gridz - limits['zmin'])) zargmax = np.argmin(np.abs(sdf_gridz - limits['zmax'])) sdf_gridx = sdf_gridx[xargmin:xargmax] sdf_gridy = sdf_gridy[yargmin:yargmax] sdf_dens = sdf_dens[xargmin:xargmax,yargmin:yargmax] if is3d: sdf_gridz = sdf_gridz[zargmin:zargmax] sdf_dens = sdf_dens[:,:,zargmin:zargmax] #take on axis density slice for plotting if is3d: plot_dens_xy = sdf_dens[:,:,int(0.5*sdf_dens.shape[2])] plot_dens_xz = sdf_dens[:,int(0.5*sdf_dens.shape[1]),:] else: plot_dens_xy = sdf_dens ### Electron selection magic happens here energy_mask = sdf_e_px > cutoff_px position_mask = np.full(sdf_e_px.shape, True, dtype=bool) if ellipse_sane: if is3d: position_mask = ( ((sdf_e_x - ell['centerx'])**2 / (ell['radx']**2)) + ((sdf_e_y - ell['centery'])**2 / (ell['rady']**2)) + ((sdf_e_z - ell['centerz'])**2 / (ell['radz']**2)) < 1 ) else: position_mask = ( ((sdf_e_x - ell['centerx'])**2 / (ell['radx']**2)) + ((sdf_e_y - ell['centery'])**2 / (ell['rady']**2)) < 1 ) bunch_electron_mask = np.where(np.logical_and(energy_mask, position_mask)) bunch_electron_x = sdf_e_x[bunch_electron_mask].reshape(-1) bunch_electron_y = sdf_e_y[bunch_electron_mask].reshape(-1) bunch_electron_w = sdf_e_w[bunch_electron_mask].reshape(-1) if is3d: bunch_electron_z = sdf_e_z[bunch_electron_mask].reshape(-1) print("Found {} particles meeting criteria".format(len(bunch_electron_w))) ### Histogram Grid creation ### if grids['xgrid'] is not None: xbins = np.arange(limits['xmin'],limits['xmax']+grids['xgrid'],grids['xgrid']) else: xbins = np.linspace(limits['xmin'],limits['xmax'],grids['xbins']) if grids['ygrid'] is not None: if limits['ymin'] * limits['ymax'] < 0: ybins = np.sort(np.concatenate(( np.arange(0,limits['ymin']-grids['ygrid'],-grids['ygrid']), np.arange(grids['ymin'],limits['ymax']+grids['ygrid'],grids['ygrid'])))) else: ybins = np.arange(limits['ymin'],limits['ymax']+grids['ygrid'],grids['ygrid']) else: if limits['ymin'] * limits['ymax'] < 0: ybins = np.sort(np.concatenate(( np.linspace(limits['ymin'],0,grids['ybins']//2), np.linspace(0,limits['ymax'],grids['ybins']//2)[1:]))) else: ybins = np.linspace(limits['ymin'],limits['ymax'],grids['ybins']) if is3d: if grids['zgrid'] is not None: if limits['zmin'] * limits['zmax'] < 0: zbins = np.sort(np.concatenate(( np.arange(0,limits['zmin']-grids['zgrid'],-grids['zgrid']), np.arange(grids['zmin'],limits['zmax']+grids['zgrid'],grids['zgrid'])))) else: zbins = np.arange(limits['zmin'],limits['zmax']+grids['zgrid'],grids['zgrid']) else: if limits['zmin'] * limits['zmax'] < 0: zbins = np.sort(np.concatenate(( np.linspace(limits['zmin'],0,grids['zbins']//2), np.linspace(0,limits['zmax'],grids['zbins']//2)[1:]))) else: zbins = np.linspace(limits['zmin'],limits['zmax'],grids['ybins']) display_limits = [ limits[l]*1e6 for l in ['xmin','xmax','ymin','ymax'] ] ### Histogram Creation ### if is3d: pos_data_3d = np.column_stack([bunch_electron_x ,bunch_electron_y ,bunch_electron_z]) counts3d, histedges = np.histogramdd(pos_data_3d ,bins=[xbins,ybins,zbins] ,weights=bunch_electron_w) vols3d = np.einsum('i,j,k',*[np.diff(a) for a in histedges]) hist_dens3d = counts3d / vols3d counts2d_xy = np.sum(counts3d, axis=2) counts2d_xz = np.sum(counts3d, axis=1) areas2d_xz = np.outer(np.diff(histedges[0]),np.diff(histedges[2])) hist_dens2d_xz = counts2d_xz / areas2d_xz counts1d_z = np.sum(counts3d, axis=(0,1)) print("max(hist_dens3d): {}".format(hist_dens3d.max())) else: pos_data_2d = np.column_stack([bunch_electron_x ,bunch_electron_y]) counts2d_xy, histedges = np.histogramdd(pos_data_2d ,bins=[xbins,ybins] ,weights=bunch_electron_w) areas2d_xy = np.outer(np.diff(histedges[0]),np.diff(histedges[1])) hist_dens2d_xy = counts2d_xy / areas2d_xy counts1d_x = np.sum(counts2d_xy,axis=1) counts1d_y = np.sum(counts2d_xy,axis=0) print("max(hist_dens2d): {}".format(hist_dens2d_xy.max())) print("max(sdf_dens): {}".format(sdf_dens.max())) ### Statistical Calculations fwnm_lim = 100 bin_w_x = np.diff(histedges[0]) bin_ctr_x = histedges[0][:-1] + bin_w_x bin_w_y = np.diff(histedges[1]) bin_ctr_y = histedges[1][:-1] + bin_w_y if is3d: bin_w_z = np.diff(histedges[2]) bin_ctr_z = histedges[2][:-1] + bin_w_z nx_rms = bin_ctr_x[np.where(counts1d_x > counts1d_x.max()/np.e)] nx_fwhm = bin_ctr_x[np.where(counts1d_x > counts1d_x.max()/2)] nx_fwnm = bin_ctr_x[np.where(counts1d_x > counts1d_x.max()/fwnm_lim)] rms_x = nx_rms.max() - nx_rms.min() fwhm_x = nx_fwhm.max() - nx_fwhm.min() fwnm_x = nx_fwnm.max() - nx_fwnm.min() x_avg = np.average(bunch_electron_x, weights=bunch_electron_w) x_vari = np.average((bunch_electron_x - x_avg)**2, weights=bunch_electron_w) x_stdev = np.sqrt(x_vari) print("X-avg: {}".format(x_avg)) print("Bunch RMS(x): {}".format(rms_x)) print("Bunch FWHM(x): {}".format(fwhm_x)) print("Bunch FW{}M(x): {}".format(fwnm_lim,fwnm_x)) print("Bunch pos stdev(x): {}".format(x_stdev)) print() ny_rms = bin_ctr_y[np.where(counts1d_y > counts1d_y.max()/np.e)] ny_fwhm = bin_ctr_y[np.where(counts1d_y > counts1d_y.max()/2)] ny_fwnm = bin_ctr_y[np.where(counts1d_y > counts1d_y.max()/fwnm_lim)] rms_y = ny_rms.max() - ny_rms.min() fwhm_y = ny_fwhm.max() - ny_fwhm.min() fwnm_y = ny_fwnm.max() - ny_fwnm.min() y_avg = np.average(bunch_electron_y, weights=bunch_electron_w) y_vari = np.average((bunch_electron_y - y_avg)**2, weights=bunch_electron_w) y_stdev = np.sqrt(y_vari) print("Bunch RMS(y): {}".format(rms_y)) print("Bunch FWHM(y): {}".format(fwhm_y)) print("Bunch FW{}M(y): {}".format(fwnm_lim,fwnm_y)) print("Bunch pos stdev(y): {}".format(y_stdev)) print() if is3d: nz_rms = bin_ctr_z[np.where(counts1d_z > counts1d_z.max()/np.e)] nz_fwhm = bin_ctr_z[np.where(counts1d_z > counts1d_z.max()/2)] nz_fwnm = bin_ctr_z[np.where(counts1d_z > counts1d_z.max()/fwnm_lim)] rms_z = nz_rms.max() - nz_rms.min() fwhm_z = nz_fwhm.max() - nz_fwhm.min() fwnm_z = nz_fwnm.max() - nz_fwnm.min() z_avg = np.average(bunch_electron_z, weights=bunch_electron_w) z_vari = np.average((bunch_electron_z - z_avg)**2, weights=bunch_electron_w) z_stdev = np.sqrt(z_vari) print("Bunch RMS(z): {}".format(rms_z)) print("Bunch FWHM(z): {}".format(fwhm_z)) print("Bunch FW{}M(z): {}".format(fwnm_lim,fwnm_z)) print("Bunch pos stdev(z): {}".format(z_stdev)) print() if not is3d: unscaled_charge = np.sum(counts2d_xy)*sc.e print("Unscaled charge: {}".format(unscaled_charge)) xm, ym, = np.meshgrid(bin_ctr_x, bin_ctr_y, indexing='ij') bunch_charge_rad = np.sum(np.abs(ym)*counts2d_xy)*np.pi*sc.e bunch_charge_dep = unscaled_charge*fwnm_y print("Total charge(rad): {:03g}pc".format(bunch_charge_rad*1e12)) print("Total charge(depth): {:03g}pc".format(bunch_charge_dep*1e12)) else: unscaled_charge = np.sum(counts3d)*sc.e print("Total charge: {:03g}pc".format(unscaled_charge*1e12)) ### Debug Plot #### fig = mf.Figure(figsize=(12,12)) canvas = mplbea.FigureCanvasAgg(fig) ax1 = fig.add_subplot(331) ax1.imshow(plot_dens_xy.T ,aspect='auto' ,extent=display_limits ,origin='upper' ,norm=mc.LogNorm(1e23,1e26) ,cmap=mcm.plasma) ax1.xaxis.set_major_locator(mt.LinearLocator(5)) if None not in ell.values(): ax1.add_patch(mpat.Ellipse((ell['centerx']*1e6,ell['centery']*1e6) ,2*ell['radx']*1e6 ,2*ell['rady']*1e6 ,fill=True ,fc='blue' ,alpha=0.2)) if is3d: ax2 = fig.add_subplot(334) ax2.imshow(plot_dens_xz.T ,aspect='auto' ,extent=display_limits ,origin='upper' ,norm=mc.LogNorm(1e23,1e26) ,cmap=mcm.plasma) ax2.xaxis.set_major_locator(mt.LinearLocator(5)) if None not in ell.values(): ax2.add_patch(mpat.Ellipse((ell['centerx']*1e6,ell['centery']*1e6) ,2*ell['radx']*1e6 ,2*ell['radz']*1e6 ,fill=True ,fc='blue' ,alpha=0.2)) ax3 = fig.add_subplot(332) ax3.imshow(hist_dens2d_xy.T ,aspect='auto' ,extent=display_limits ,origin='upper' ,norm=mc.LogNorm(np.ma.masked_equal(hist_dens2d_xy,0,copy=False).min() ,np.ma.masked_equal(hist_dens2d_xy,0,copy=False).max()) ,cmap=mcm.plasma) ax3.xaxis.set_major_locator(mt.LinearLocator(5)) if is3d: ax4 = fig.add_subplot(335) ax4.imshow(hist_dens2d_xz.T ,aspect='auto' ,extent=display_limits ,origin='upper' ,norm=mc.LogNorm(np.ma.masked_equal(hist_dens2d_xz,0,copy=False).min() ,np.ma.masked_equal(hist_dens2d_xz,0,copy=False).max()) ,cmap=mcm.plasma) ax4.xaxis.set_major_locator(mt.LinearLocator(5)) # Charge x-distribution ax5 = fig.add_subplot(337) bars = ax5.bar(bin_ctr_x*1e6 ,counts1d_x ,width=bin_w_x*1e6 ,linewidth=0 ) mask_count = np.ma.masked_equal(counts1d_x, 0, copy=False) norm = mc.Normalize(mask_count.min(),mask_count.max()) for i,patch in enumerate(bars.patches): if counts1d_x[i] > 0: patch.set_facecolor(mcm.plasma(norm(counts1d_x[i]))) #Indicate extents of bunch measurements ax5.axvline(nx_rms.min()*1e6,alpha=0.5, color='red') ax5.axvline(nx_rms.max()*1e6,alpha=0.5, color='red') ax5.axvline(nx_fwhm.min()*1e6,alpha=0.5, color='green') ax5.axvline(nx_fwhm.max()*1e6,alpha=0.5, color='green') ax5.axvline(nx_fwnm.min()*1e6,alpha=0.5, color='blue') ax5.axvline(nx_fwnm.max()*1e6,alpha=0.5, color='blue') #naive attempt to autoscale delta = 0.1*(nx_fwnm.max() - nx_fwnm.min()) ax5.set_xlim((nx_fwnm.min()-delta)*1e6 ,(nx_fwnm.max()+delta)*1e6) ax5.set_xlabel(r'$z\ \mathrm{(\mu m)}$') ax5.set_ylabel(r'$\mathrm{d}Q\ \mathrm{(C m^{-3})}$') ax5.xaxis.set_major_locator(mt.MaxNLocator(5)) #Charge y_distribution ax6 = fig.add_subplot(333) bars = ax6.bar(bin_ctr_y*1e6 ,counts1d_y ,width=bin_w_y*1e6 ,linewidth=0 ) norm = mc.Normalize(counts1d_y.min(),counts1d_y.max()) for i,patch in enumerate(bars.patches): if counts1d_y[i] > 0: patch.set_facecolor(mcm.plasma(norm(counts1d_y[i]))) #Indicate extents of bunch measurements ax6.axvline(ny_rms.min()*1e6,alpha=0.5, color='red') ax6.axvline(ny_rms.max()*1e6,alpha=0.5, color='red') ax6.axvline(ny_fwhm.min()*1e6,alpha=0.5, color='green') ax6.axvline(ny_fwhm.max()*1e6,alpha=0.5, color='green') ax6.axvline(ny_fwnm.min()*1e6,alpha=0.5, color='blue') ax6.axvline(ny_fwnm.max()*1e6,alpha=0.5, color='blue') #naive attempt to autoscale delta = 0.1*(ny_fwnm.max() - ny_fwnm.min()) ax6.set_xlim((ny_fwnm.min()-delta)*1e6 ,(ny_fwnm.max()+delta)*1e6) ax6.set_xlabel(r'$z\ \mathrm{(\mu m)}$') ax6.set_ylabel(r'$\mathrm{d}Q\ \mathrm{(C m^{-3})}$') #z-density distribution if is3d: ax7 = fig.add_subplot(336) bars = ax7.bar(bin_ctr_z*1e6 ,counts1d_z ,width=bin_w_z*1e6 ,linewidth=0 ) norm = mc.Normalize(counts1d_z.min(),counts1d_z.max()) for i,patch in enumerate(bars.patches): if counts1d_z[i] > 0: patch.set_facecolor(mcm.plasma(norm(counts1d_z[i]))) #Indicate extents of bunch measurements ax7.axvline(nz_rms.min()*1e6,alpha=0.5, color='red') ax7.axvline(nz_rms.max()*1e6,alpha=0.5, color='red') ax7.axvline(nz_fwhm.min()*1e6,alpha=0.5, color='green') ax7.axvline(nz_fwhm.max()*1e6,alpha=0.5, color='green') ax7.axvline(nz_fwnm.min()*1e6,alpha=0.5, color='blue') ax7.axvline(nz_fwnm.max()*1e6,alpha=0.5, color='blue') #naive attempt to autoscale delta = 0.1*(nz_fwnm.max() - nz_fwnm.min()) ax7.set_xlim((nz_fwnm.min()-delta)*1e6 ,(nz_fwnm.max()+delta)*1e6) ax7.set_xlabel(r'$z\ \mathrm{(\mu m)}$') ax7.set_ylabel(r'$\mathrm{d}Q\ \mathrm{(C m^{-3})}$') #Finally print all the numerical results ax8 = fig.add_subplot(338) ax8.axis('off') # Bunch Charge if is3d: props_string = r'\noindent$Q = {:.3}\ \mathrm{{pC}}$\\ \\'.format(unscaled_charge*1e12) else: props_string = ''.join( [r'\noindent$dQ = {:.3}\ \mathrm{{\mu C/m}}$\\'.format(unscaled_charge*1e6) ,r'$Q_w = {:.3}\ \mathrm{{pC}}$\\'.format(bunch_charge_dep*1e12) ,r'$Q_r = {:.3}\ \mathrm{{pC}}$\\ \\'.format(bunch_charge_rad*1e12)]) props_string += ''.join( [r'$w_x(RMS) = {:.3}\ \mathrm{{\mu m}}$\\'.format(rms_x*1e6) ,r'$w_x(FWHM) = {:.3}\ \mathrm{{\mu m}}$\\'.format(fwhm_x*1e6) ,r'$w_x(FW{}M) = {:.3}\ \mathrm{{\mu m}}$\\'.format(fwnm_lim,fwnm_x*1e6) ,r'$\sigma_x = {:.3}\ \mathrm{{\mu m}}$\\ \\'.format(x_stdev*1e6) ,r'$w_y(RMS) = {:.3}\ \mathrm{{\mu m}}$\\'.format(rms_y*1e6) ,r'$w_y(FWHM) = {:.3}\ \mathrm{{\mu m}}$\\'.format(fwhm_y*1e6) ,r'$w_y(FW{}M) = {:.3}\ \mathrm{{\mu m}}$\\'.format(fwnm_lim,fwnm_y*1e6) ,r'$\sigma_y = {:.3}\ \mathrm{{\mu m}}$\\ \\'.format(y_stdev*1e6)]) if is3d: props_string += ''.join( [r'$w_z(RMS) = {:.3}\ \mathrm{{\mu m}}$\\'.format(rms_z*1e6) ,r'$w_z(FWHM) = {:.3}\ \mathrm{{\mu m}}$\\'.format(fwhm_z*1e6) ,r'$w_z(FW{}M) = {:.3}\ \mathrm{{\mu m}}$\\'.format(fwnm_lim,fwnm_z*1e6) ,r'$\sigma_z = {:.3}\ \mathrm{{\mu m}}$\\'.format(z_stdev*1e6)]) ax8.text(0,0.95 ,props_string ,transform=ax8.transAxes ,verticalalignment='top' ) fig.savefig('{}/{}_debug_fwhm.png'.format(output_path,output_name)) ### Publication Plot ax1loc=[0.09,0.15,0.37,0.625] ax2loc=[0.59,0.15,0.37,0.625] ax1cbloc=[0.09,0.8,0.37,0.05] ax2cbloc=[0.59,0.8,0.37,0.05] ax1norm=mc.LogNorm(1e23,1e26) if reset_origin: origin_offset = display_limits[0] display_limits[0] = 0 display_limits[1] -= origin_offset else: origin_offset = 0 mpl.rcParams.update({'font.size': 8}) fig = mf.Figure(figsize=(3.2,2)) canvas = mplbea.FigureCanvasAgg(fig) ax = fig.add_axes(ax1loc) ax.imshow(plot_dens_xy.T ,aspect='auto' ,extent=display_limits ,origin='upper' ,norm=ax1norm ,cmap=mcm.plasma) ax1cba = fig.add_axes(ax1cbloc) ax1cb = mplcb.ColorbarBase(ax1cba ,cmap=mcm.plasma ,norm=ax1norm ,orientation='horizontal') ax1cba.tick_params(top=True,labelbottom=False,labeltop=True,pad=-1) ax1cb.set_ticks((ax1norm.vmin,ax1norm.vmax)) ax1cba.xaxis.set_label_position('top') ax1cb.set_label(r"$n_e\ \mathrm{m^{-3}}$", labelpad=-4) ax.xaxis.set_major_locator(mt.LinearLocator(3)) ax.yaxis.set_major_locator(mt.LinearLocator(3)) ax.set_xlabel(r'$z\ \mathrm{(\mu m)}$', labelpad=0) ax.set_ylabel(r'$y \mathrm{(\mu m)}$', labelpad=-5) ax2 = fig.add_axes(ax2loc) counts, xbins, patches = ax2.hist(bunch_electron_x*1e6 - origin_offset ,bins=xbins*1e6 - origin_offset ,weights=bunch_electron_w*sc.e*1e12 ,linewidth=0) cnz = counts[np.nonzero(counts)] pnz = np.asarray(patches)[np.nonzero(counts)] try: ax2nmax = float(config['pub_cmax']) except: ax2nmax = np.power(10,np.ceil(np.log10(cnz.max()))) try: ax2nmin = float(config['pub_cmin']) except: ax2nmin = np.power(10,np.floor(np.log10(cnz.min()))) ax2norm = mc.LogNorm(ax2nmin, ax2nmax) for count, patch in zip(cnz,pnz): patch.set_facecolor(mcm.plasma(ax2norm(count))) if lineout_inset: insax = mil.inset_axes(ax2, width="50%", height="50%", loc=2) iap = insax.get_position() insax.set_position([iap.xmin + 0.05, iap.ymin, iap.width, iap.height]) for patch in patches: patch_cpy = copy.copy(patch) patch_cpy.axes = None patch_cpy.figure = None patch_cpy.set_transform(insax.transData) insax.add_patch(patch_cpy) insax.yaxis.set_ticks_position("right") insax.autoscale() insax.set_xlim(lineout_xmin, lineout_xmax) insax.set_ylim(lineout_ymin, lineout_ymax) insax.xaxis.set_major_locator(mt.LinearLocator(2)) insax.yaxis.set_major_locator(mt.LinearLocator(2)) insax.axes.tick_params(labelsize="small") # [tick.label.set_fontsize(6) for tick in insax.xaxis.get_major_ticks()] # [tick.label.set_fontsize(6) for tick in insax.yaxis.get_major_ticks()] ax2cba = fig.add_axes(ax2cbloc) ax2cb = mplcb.ColorbarBase(ax2cba ,cmap=mcm.plasma ,norm=ax2norm ,orientation='horizontal') ax2cba.tick_params(top=True,labelbottom=False,labeltop=True,pad=-1) ax2cb.set_ticks((ax2norm.vmin,ax2norm.vmax)) ax2cba.xaxis.set_label_position('top') ax2cb.set_label(r"$\mathrm{d}Q/\mathrm{d}z\ \mathrm{nC/m}$", labelpad=-4) ax2.set_xlim(pub_xmin, pub_xmax) ax2.set_ylim(pub_ymin, pub_ymax) ax2.xaxis.set_major_locator(mt.LinearLocator(3)) ax2.yaxis.set_major_locator(mt.LinearLocator(3)) ax2.set_xlabel(r'$z\ \mathrm{(\mu m)}$',labelpad=0) ax2.set_ylabel(r'$\mathrm{d}Q/\mathrm{d}z\ \mathrm{(nC/m)}$',labelpad=0) try: fig.text(0.05,0.94,'{}'.format(config['title']) ,transform=fig.transFigure, fontsize=10) except Exception as err: print(err) fig.savefig('{}/{}_pub_fwhm.png'.format(output_path,output_name) ,dpi=300)
def main(): species = "Electron" path = "/scratch/lsa_flux/diiorios/2d_run/" fnums = ["0100", "0200", "0400"] fname = [] for n in fnums: fname.append(path + n + ".sdf") x_axis_num = 0 y_axis_num = 1 # z_axis_num = 2 fig, axarr = plt.subplots(len(fname), sharex=True)#, sharey=True) fig.set_facecolor("w") # only have a single file to plot, so we so this little hack since # axarr does not come out in an array in this case if not isinstance(axarr, np.ndarray): axarr = np.array([axarr]) # axarr[0].set_title(species + " files " + str(fnums)) # axarr[0].set_title('Contribution to E Field') limit = 8E9 for i in range(len(fname)): sdfdata = sdf.read(fname[i]) print(sdfdata.Header['time']) e_var_x = sdfdata.Electric_Field_Ex e_var_y = sdfdata.Electric_Field_Ey x_grid = e_var_x.grid_mid.data[0] y_grid = e_var_y.grid_mid.data[1] x_grid_cent = e_var_x.grid.data[0] y_grid_cent = e_var_y.grid.data[1] e_avg, dummy_e_r, dummy_e_t = __radial_average(x_grid, y_grid, e_var_x.data, e_var_y.data) dummy_temp_grid_x, temp_data_x = Temp_Field(sdfdata, x_axis_num, species='Electron') dummy_temp_grid_y, temp_data_y = Temp_Field(sdfdata, y_axis_num, species='Electron') temp_avg, dummy_temp_r, dummy_temp_t = __radial_average(x_grid, y_grid, temp_data_x, temp_data_y) dummy_res_mhd_grid_x, res_mhd_data_x = Resistive_MHD_Field(sdfdata, x_axis_num) dummy_res_mhd_grid_y, res_mhd_data_y = Resistive_MHD_Field(sdfdata, y_axis_num) rmhd_avg, dummy_rmhd_r, dummy_rmhd_t = __radial_average(x_grid, y_grid, res_mhd_data_x, res_mhd_data_y) dummy_hall_grid_x, hall_data_x = Hall_Field(sdfdata, x_axis_num) dummy_hall_grid_y, hall_data_y = Hall_Field(sdfdata, y_axis_num) hall_avg, dummy_hall_r, dummy_hall_t = __radial_average(x_grid, y_grid, hall_data_x, hall_data_y) gen_data_x = Generalized_Ohm(sdfdata, x_axis_num, species='Electron') gen_data_y = Generalized_Ohm(sdfdata, y_axis_num, species='Electron') gen_avg, dummy_gen_r, dummy_gen_t = __radial_average(x_grid, y_grid, gen_data_x, gen_data_y) gen_avg2 = Generalized_Ohm_radavg(sdfdata, species='Electron') high_order = higher_order(sdfdata, species='Electron') cart_high_x = cart_higher_order_x(sdfdata, species='Electron') cart_high_y = cart_higher_order_y(sdfdata, species='Electron') cart_high_avg, dummy_high_r, dummy_high_t = __radial_average(x_grid_cent, y_grid_cent, cart_high_x, cart_high_y) # ideal_mhd_grid_x, ideal_mhd_data_x = Ideal_MHD_Field(sdfdata, # x_axis_num, # species='Electron') # ideal_mhd_grid_y, ideal_mhd_data_y = Ideal_MHD_Field(sdfdata, # y_axis_num, # species='Electron') # imhd_avg, imhd_r, imhd_t = __radial_average(x_grid, y_grid, ideal_mhd_data_x, ideal_mhd_data_y) l1, = axarr[i].plot(#e_r, e_avg, 'k-', label='Simulation') l2, = axarr[i].plot(#temp_r, np.clip(temp_avg, -limit, limit), 'r--', label='Pressure Tensor Gradient') # l3, = axarr[i].plot(#rmhd_r, # np.clip(rmhd_avg, -limit, limit), # 'b-.', # label='Resistive MHD') # l4, = axarr[i].plot(#hall_r, # np.clip(hall_avg, -limit, limit), # 'g:', # label='Hall Term') # l5, = axarr[i].plot(#imhd_r, # np.clip(imhd_avg, # -limit, limit), # 'm-.', # label='Ideal MHD Term') # l6, = axarr[i].plot(np.clip(gen_avg, -limit, limit), # 'm-.', # label='Generalized Ohm', # alpha=0.2) l7, = axarr[i].plot(np.clip(gen_avg2, -limit, limit), 'b-.', label='Ohm Law 1st Term') l8, = axarr[i].plot(np.clip(high_order, -limit, limit), 'g:', label='Ohm Law 2nd Term') # l9, = axarr[i].plot(np.clip(cart_high_avg, -limit, limit), # 'b:', # label='Cart Higher Order') ls = [l1, l2, l7, l8] #l3, l4, l5] labels = [l.get_label() for l in ls] lgd = fig.legend(ls, labels, bbox_to_anchor=(1.05, 1.0), loc=1) fig.subplots_adjust(hspace=0) plt.setp([a.get_xticklabels() for a in fig.axes[:-1]], visible=False) # plt.xlim(-6.5e-6, 6.5e-6) # plt.ylim(-limit, limit) # xmult, xsym = get_si_prefix(np.max(e_r) - np.min(e_r)) ymult, ysym = get_si_prefix(limit - (-limit)) # axarr[0].xaxis.set_major_formatter(FuncFormatter(lambda x, y: (x * xmult))) axarr[0].yaxis.set_major_formatter(FuncFormatter(lambda x, y: (x * ymult))) axarr[1].yaxis.set_major_formatter(FuncFormatter(lambda x, y: (x * ymult))) axarr[2].yaxis.set_major_formatter(FuncFormatter(lambda x, y: (x * ymult))) axarr[0].set_ylim([-limit, limit]) axarr[1].set_ylim([-limit, limit]) axarr[2].set_ylim([-limit, limit]) xmult, xsym = get_si_prefix(dummy_e_r.max() - dummy_e_r.min()) # axarr[2].xaxis.set_major_formatter(FuncFormatter(lambda x, y: (x * xmult))) # axarr[2].set_xlim([dummy_e_r.min(), dummy_e_r.max()]) plt.xlabel('r' + ' $(' + xsym + 'm)$') axarr[1].set_ylabel('$E_{r}$ $(' + ysym + 'V/m)$') # plt.show() axarr[0].get_yaxis().set_tick_params(direction='in') axarr[1].get_yaxis().set_tick_params(direction='in') axarr[2].get_yaxis().set_tick_params(direction='in') axarr[2].get_xaxis().set_tick_params(direction='in') plt.savefig('ohm_rad.png', dpi=600, bbox_extra_artists=(lgd,), bbox_inches = "tight", pad_inches=0.2) plt.close(fig)
def sdfr(filename): return sdf.read(filename)
import numpy as np import matplotlib.pyplot as plt import sdf plt.switch_backend('agg') x = 18000 sdfdir = "../Data/acceleration/" savefigdir = "./acceleration/fig/" + str(x) data = sdf.read(sdfdir + str(x) + ".sdf", dict=True) data Bz = data['Magnetic Field/Bz'] bz = Bz.data density = data['Derived/Number_Density/electron'].data bz = bz.T dengsity = density.T fig, ax = plt.subplots() fig2, ax2 = plt.subplots() im = ax.pcolormesh(bz, cmap=plt.get_cmap('rainbow')) im2 = ax2.pcolormesh(density, cmap=plt.get_cmap('gray')) fig.savefig(savefigdir + "bz.png", dpi=200) fig2.savefig(savefigdir + "density.png", dpi=200)
grid_x = grid_x[np.in1d(temp_id, part13_id)] grid_z = grid_z[np.in1d(temp_id, part13_id)] plt.scatter(grid_x, grid_z, c='lime', s=0.03, edgecolors='None', alpha=0.8, zorder=2) if __name__ == '__main__': from_path = './cannon_a190_v484/' to_path = './cannon_a190_v484_fig/' ######### Script code drawing figure ################ data = sdf.read(from_path + "i_tot_loc0027.sdf", dict=True) px = data['Particles/Px/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) py = data['Particles/Py/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) pz = data['Particles/Pz/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) theta = np.arctan2((py**2 + pz**2)**0.5, px) * 180.0 / np.pi gg = (px**2 + py**2 + pz**2 + 1)**0.5 Ek = (gg - 1) * 1836 * 0.51 part13_id = data['Particles/ID/subset_Only_Ions0/Ion'].data part13_id = part13_id[(Ek > 220) & (abs(theta) < 10) & (Ek < 240)] print('part13_id size is ', part13_id.size, ' max ', np.max(part13_id), ' min ', np.min(part13_id)) plt.subplot(1, 1, 1) one_procedure(n=17) # plt.contour(X, Z, den_e.T,levels=[30.0], colors='white', linewidths=2.,origin='lower') plt.xlim(8, 24)
def processplot(n): to_path = './cannon_a190_bulk200/' from_path = './cannon_a190_bulk200/' data = sdf.read(from_path + "i_tot_loc0027.sdf", dict=True) #grid_x = data['Grid/Particles/subset_high_e/electron'].data[0]/wavelength px = data['Particles/Px/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) py = data['Particles/Py/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) pz = data['Particles/Pz/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) theta = np.arctan2((py**2 + pz**2)**0.5, px) * 180.0 / np.pi gg = (px**2 + py**2 + pz**2 + 1)**0.5 Ek = (gg - 1) * 1836 * 0.51 part13_id = data['Particles/ID/subset_Only_Ions0/Ion'].data part13_id = part13_id[(Ek > 225) & (abs(theta) < 10) & (Ek < 245)] #choice = np.random.choice(range(part13_id.size), 20000, replace=False) #part13_id = part13_id[choice] print('part13_id size is ', part13_id.size, ' max ', np.max(part13_id), ' min ', np.min(part13_id)) ######### Script code drawing figure ################ #for n in range(start,stop+step,step): #### header data #### #data = sdf.read(from_path+str(n).zfill(4)+".sdf",dict=True) #header=data['Header'] #time=header['time'] #x = data['Grid/Grid_mid'].data[0]/1.0e-6 #y = data['Grid/Grid_mid'].data[1]/1.0e-6 #X, Y = np.meshgrid(x, y) data = sdf.read(from_path + "i_tot_loc" + str(n).zfill(4) + ".sdf", dict=True) header = data['Header'] time1 = header['time'] px = data['Particles/Px/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) py = data['Particles/Py/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) pz = data['Particles/Pz/subset_Only_Ions0/Ion'].data / (1836 * m0 * v0) gg = (px**2 + py**2 + pz**2 + 1)**0.5 theta = np.arctan2((py**2 + pz**2)**0.5, px) * 180.0 / np.pi grid_x = data['Grid/Particles/subset_Only_Ions0/Ion'].data[0] / 1.0e-6 temp_id = data['Particles/ID/subset_Only_Ions0/Ion'].data px = px[theta < 20] grid_x = grid_x[theta < 20] theta = theta[theta < 20] if np.size(px) == 0: return 0 theta[theta < -20] = -20 theta[theta > 20] = 20 color_index = abs(theta) fig, host = plt.subplots() # plt.subplot() plt.scatter(grid_x, px, c=color_index, s=0.03, cmap='rainbow_r', edgecolors='None', alpha=0.66) cbar = plt.colorbar(ticks=np.linspace(np.min(color_index), np.max(color_index), 5), pad=0.01) cbar.ax.set_yticklabels(cbar.ax.get_yticklabels(), fontsize=20) cbar.set_label(r'$|\theta|$' + ' [degree]', fontdict=font) #plt.plot(np.linspace(-500,900,1001), np.zeros([1001]),':k',linewidth=2.5) #plt.plot(np.zeros([1001]), np.linspace(-500,900,1001),':k',linewidth=2.5) #plt.plot(np.linspace(-500,900,1001), np.linspace(-500,900,1001),'-g',linewidth=3) #plt.plot(np.linspace(-500,900,1001), 200-np.linspace(-500,900,1001),'-',color='grey',linewidth=3) # plt.legend(loc='upper right') plt.xlim(-5, 55) plt.ylim(0., 1.6) plt.xlabel('X [$\mu m$]', fontdict=font) plt.ylabel('$p_x$ [m$_i$c$^2$]', fontdict=font) plt.xticks(fontsize=20) plt.yticks(fontsize=20) # plt.text(-100,650,' t = '++' fs',fontdict=font) plt.subplots_adjust(left=0.16, bottom=None, right=0.97, top=None, wspace=None, hspace=None) plt.title('At ' + str(round(time1 / 1.0e-15, 2)) + ' fs', fontdict=font) #plt.show() #lt.figure(figsize=(100,100)) par1 = host.twinx() par2 = host.twinx() par3 = host.twinx() par2.spines["right"].set_position(("axes", 1.05)) make_patch_spines_invisible(par2) par2.spines["right"].set_visible(True) par3.spines["right"].set_position(("axes", 1.1)) make_patch_spines_invisible(par3) par3.spines["right"].set_visible(True) tkw = dict(size=20, width=1.) x = np.loadtxt(from_path + 'ex_lineout_x.txt') ex = np.loadtxt(from_path + 'ex_lineout_r15_' + str(n).zfill(4) + '.txt') p1, = par1.plot(x, ex, "-k", label="Ex") par1.set_ylabel(r'$E_x\ [m_ec\omega/|e|]$') par1.yaxis.label.set_color(p1.get_color()) par1.tick_params(axis='y', colors=p1.get_color(), **tkw) par1.set_ylim(-10, 15) x = np.loadtxt(from_path + 'eden_lineout_x.txt') eden = np.loadtxt(from_path + 'eden_lineout_r15_' + str(n).zfill(4) + '.txt') #*exunit/denunit p2, = par2.plot(x, eden, "-b", label="Electron") par2.set_ylabel('$n_e\ [n_c]$') par2.yaxis.label.set_color(p2.get_color()) par2.tick_params(axis='y', colors=p2.get_color(), **tkw) par2.set_ylim(0, 30) x = np.loadtxt(from_path + 'iden_lineout_x.txt') iden = np.loadtxt(from_path + 'iden_lineout_r15_' + str(n).zfill(4) + '.txt') #*exunit/denunit p3, = par3.plot(x, iden, "-r", label="Ion") par3.set_ylabel('$n_i\ [n_c]$') par3.yaxis.label.set_color(p3.get_color()) par3.tick_params(axis='y', colors=p3.get_color(), **tkw) par3.set_ylim(0, 30) fig = plt.gcf() fig.set_size_inches(12, 7.5) fig.savefig(to_path + 'r15_comb_proton' + str(n).zfill(4) + '.png', format='png', dpi=80) plt.close("all") print('finised ' + str(n).zfill(4)) return 0