#parameters for xpoint detection edge = 4 smoothlen = 1 myroll = 2 bdens_tolerence = 4 zero_tolerence = 2 grid_to_plot_coord = istep / c_omp / 1000. #converting output field coords to plotting units for t in range(t0, tf): #myfld = "../../tristan_acc-mec_Ez/8k_untriggered_bguide.3_stride1/output/flds.tot." t_str = '%03d' % t myfld = fld_base + t_str print(t_str) myfld = h5py.File(myfld, 'r') vecpot = vecpot2(myfld, istep, c_omp) #print(np.shape(vecpot)) xpoint_loc, leftcut, rightcut, bottomcut, topcut = return_xpoints( myfld, edge, smoothlen, myroll, bdens_tolerence, zero_tolerence) dens = myfld['dens'][0, bottomcut:topcut, leftcut:rightcut] #dens = np.rot90(get_val_filename('dens',myfld)[0,:,:]) dens_shape = np.shape(dens) xlen = dens_shape[1] xext = xlen * grid_to_plot_coord yext = dens_shape[0] * grid_to_plot_coord vecpot = vecpot2(myfld, istep, c_omp) print('xext : ', xext) print('yext : ', yext)
# fld_base += "00" + tstr #elif len(tstr)==2: # fld_base += "0"+tstr t0 = 50 tf = 51 for t in range(t0, tf): t_string = str(t) myfld = fld_base + t_string myfld = h5py.File(myfld, 'r') dens = get_val_filename('dens', myfld)[0, :, :] bdens = myfld['bdens'][0, :, :] vecpot = vecpot2(myfld, 12, 3) #fig, (ax1, ax2, ax3) = plt.subplots(3,1,sharex=True) fig, (ax0) = plt.subplots(1, 1, sharex=True) #ax1.imshow(np.rot90(dens)/5,origin='lower',cmap='viridis',vmin=0,vmax=5) #ax2.imshow(np.rot90(vecpot),origin='lower',cmap='jet') #plt.savefig('vecpot_test.png') #identify midplane ax0.imshow(np.rot90(dens) / 4., origin='lower', vmin=0, vmax=5) #ax1.imshow(np.rot90(vecpot),origin='lower') #plt.colorbar(im1) #plt.colorbar(im0) #plt.colorbar(orientation='horizontal',label='$A_{z}$') #plt.savefig('vecpot_fld.png',dpi=300,bbox_inches='tight') localmin_x, localmin_y = localmin_2d_bdens(vecpot, 3, bdens, 1) print('num x points : ', len(localmin_x))
for i in range(4, 5): for j in range(3, 4): if matrix_namelist[i][j] == "pass": pass else: print(i, j) myname = matrix_namelist[i][j] for t in range(t_start, t_final): t_str = str(t) print(t_str) if len(t_str) == 1: tmpname = myname + "00" + t_str elif len(t_str) == 2: tmpname = myname + "0" + t_str myf = h5py.File(tmpname, 'r') vecpot = vecpot2(myf, 12, 3) xmid = np.shape(vecpot)[1] / 2 vecpot_slice = vecpot[:, xmid] ylen = np.shape(vecpot)[0] ylenhlf = ylen / 2 time_offset = 4 time_delay = 3 myedge = max( int(ylenhlf - (va * .45 * interval * (t - time_offset) / istep / time_delay)), scan + 1) my_localmin_list = localmin(vecpot_slice, scan, myedge) my_localmax_list = localmax(vecpot_slice, scan, myedge) num_xpoints = len(my_localmin_list)
#fldbase = "../../tristan-mp_reconnection/16k_triggered_finals/sig.3/delgam00005/output/flds.tot." #fldbase = "../../tristan_acc-mec_Ez/8k_bguide.3_triggered_stride1_thresh2/output/flds.tot." fldbase = "../../tristan_acc-mec_Ez/8k_untriggered_bguide.3/output/flds.tot." #fldbase = "../../tristan_acc-mec_Ez/8k_bguide0_untriggered_stride1_thresh2/output/flds.tot." fldbase += t_str myfld = h5py.File(fldbase,'r') dens = myfld['dens'][0,:,:] bdens = myfld['bdens'][0,:,:] edge = 5 smoothlen = 1 vecpot = vecpot2(myfld,12,3)[edge:-1*edge,:] #clip off top and bottom to remove numerical issue at boundary with vector potential calc vecpot_smooth = gaussian_filter(vecpot,smoothlen) #just getting bdens to be the same shape as vecpot mx = bdens.shape[1] bdens = bdens[:,2:mx-5] bdens = bdens[edge:-1*edge,:] print(np.shape(vecpot),np.shape(bdens)) xhlf = np.shape(vecpot)[1]/2
scan = 5 myf_prtl.close() #t_list = [t_list[0]] for t in t_list: print(t) tstr = "%03d" % t myfld = fldbase + tstr myfld = h5py.File(myfld, 'r') xpoint_loc, leftcut, rightcut, bottomcut, topcut = return_xpoints( myfld, edge, smoothlen, myroll, bdens_tolerence, zero_tolerence) #using a secondary method to ensure we don't miss xpoints vecpot, junk1, junk2 = vecpot2(myfld, istep, c_omp) xmid = np.shape(vecpot)[1] / 2 vecpot_slice = vecpot[:, xmid] bdens = myfld['bdens'][0, :, :] xmid = np.shape(bdens)[1] / 2 bdens_slice = bdens[:, xmid] for index in range(np.size(vecpot_slice)): if vecpot_slice[index] == 0: pass if vecpot_slice[index] != 0: lowcount = index break vecpot_slice = vecpot_slice[lowcount:] #print('trimmed ' + str(lowcount) + ' zeros from bottom') #print('vecpot slice first 10 , ', vecpot_slice[0:10]) highcount = 0
def return_xpoints( myfld, edge, smoothlen, myroll, bdens_tolerence, zero_tolerence ): #value of 5 is fine for edge, 1 or 2 for myroll (distance over which derivatives are calculated #bdens_tolerence makes it so we don't care about stuff that happens where the particles are all just particles initialized in the current sheet, 4 works fine #zero_tolerence is how close the derivatives have to be to 0 in order to count, 2 is fine for this #one thing we could implement is a higher order construction of the derivative, might be worth looking into leftcut = 0 #adding up all the cuts to the arrays we make so we can return them at the end so we can make sure we line up the locations properly rightcut = 0 bdens = myfld['bdens'][0, :, :] vecpot, xmin, xmax = vecpot2( myfld, 12, 3 ) #clip off top and bottom to remove numerical issue at boundary with vector potential calc vecpot = vecpot[edge:-1 * edge, :] vecpot_smooth = gaussian_filter(vecpot, smoothlen) #just getting bdens to be the same shape as vecpot #print('bdens shape : ', bdens.shape) #print('vecpot shape : ', vecpot.shape) mx = bdens.shape[1] mxvec = vecpot_smooth.shape[1] mxdiff = np.abs(mx - mxvec) #print('mx, mxvec',mx,mxvec) #print('mxdiff',mxdiff) #print('init shapes') #print(vecpot_smooth.shape,bdens.shape) myx = np.shape(bdens)[1] bdens = bdens[:, xmin:xmax] bdens = bdens[edge:-1 * edge, :] #print(np.shape(vecpot_smooth),np.shape(bdens)) xhlf = np.shape(vecpot)[1] / 2 #leftcut += edge #rightcut += edge topcut = -edge bottomcut = edge leftcut += xmin rightcut = (xmax - myx) #0 axis is up along y #1 axis is in x-direction #basic central difference: dady = (np.roll(vecpot_smooth, myroll, axis=0) - np.roll(vecpot_smooth, -1 * myroll, axis=0)) / myroll dadx = (np.roll(vecpot_smooth, myroll, axis=1) - np.roll(vecpot_smooth, -1 * myroll, axis=1)) / myroll d2ad2x = (np.roll(vecpot_smooth, myroll, axis=1) - 2 * vecpot_smooth + np.roll(vecpot_smooth, -1 * myroll, axis=1)) / myroll**2 d2ad2y = (np.roll(vecpot_smooth, myroll, axis=0) - 2 * vecpot_smooth + np.roll(vecpot_smooth, -1 * myroll, axis=0)) / myroll**2 d2adydx = (np.roll(dady, myroll, axis=1) - np.roll(dady, -1 * myroll, axis=1)) / myroll d2adxdy = (np.roll(dadx, myroll, axis=0) - np.roll(dadx, -1 * myroll, axis=0)) / myroll #print('shapes before smoothlen cut', dady.shape, bdens.shape) #cutting off stuff that rolled over the boundary and results in nonsense dady = dady[:, smoothlen + 1:-smoothlen - 2] dadx = dadx[:, smoothlen + 1:-smoothlen - 2] d2ad2x = d2ad2x[:, smoothlen + 1:-smoothlen - 2] d2ad2y = d2ad2y[:, smoothlen + 1:-smoothlen - 2] d2adydx = d2adydx[:, smoothlen + 1:-smoothlen - 2] d2adxdy = d2adxdy[:, smoothlen + 1:-smoothlen - 2] #so first we're gonna have to loop through the first derivative and identify zeros. bdens = bdens[:, smoothlen + 1:-smoothlen - 2] leftcut += smoothlen + 1 rightcut += -(smoothlen + 2) bdens_loc = bdens < bdens_tolerence dadx_zero_loc = np.abs(dadx) < zero_tolerence dady_zero_loc = np.abs(dady) < zero_tolerence #print(np.shape(bdens_loc),np.shape(dadx),np.shape(dady)) first_deriv_zero_loc = dadx_zero_loc * dady_zero_loc * bdens_loc num_deriv_zero = np.sum(first_deriv_zero_loc) print('number of zero derivative points : ', num_deriv_zero) #now we loop through null points and ask the questions about 2nd derivatives ylen, xlen = np.shape(dady) #print(xlen,ylen) #testarr = np.zeros((ylen,xlen)) #print(np.shape(testarr)) saddlepoint_arr = np.zeros((ylen, xlen)) saddle_count = 0 xpoint_loc_list = [] for i in range(ylen): for j in range(xlen): #only need to do operations if its a null point if first_deriv_zero_loc[i][j] == 1: #testarr[i][j] += 1 #indexing is correct H00 = d2ad2x[i][j] #values of the hessian matrix H11 = d2ad2y[i][j] H01 = d2adydx[i][j] #coeffs of quadratic equations solving for eigenvals a = 1 b = H00 + H11 c = H00 * H11 - H01**2 #eigenvals lambdaplus = (-b + np.sqrt(b**2 - 4 * a * c)) / (2 * a) lambdaminus = (-b - np.sqrt(b**2 - 4 * a * c)) / (2 * a) #print('eigenvals : ',lambdaplus,lambdaminus) #print('eigenvec : ',-b,a-lambdaplus) if lambdaplus * lambdaminus < 0: #if they have opposite signs #if True: xpoint_loc_list.append([i, j]) saddle_count += 1 saddlepoint_arr[i][j] += 1 print('saddle point count : ', saddle_count) #remember that the returned locations are with respect to our new cut array return xpoint_loc_list, leftcut, rightcut, bottomcut, topcut