def build_gamma(f5F):
vx = read_h5_array(f5F, "Vxp")
vy = read_h5_array(f5F, "Vyp")
vz = read_h5_array(f5F, "Vzp")
gam = 1.0/np.sqrt(1.0 - vx**2 + vy**2 + vz**2)
return gam
def read_periphery(outdir, fname, var, lap):
#fields_file = conf.outdir + "/" + fname_fld + "_" + str(lap) + ".h5"
fname = "slices" #overwrite
xy_file = outdir + "/" + fname + "-xy_" + str(lap) + ".h5"
xz_file = outdir + "/" + fname + "-xz_" + str(lap) + ".h5"
yz_file = outdir + "/" + fname + "-yz_" + str(lap) + ".h5"
f5_xy = h5.File(xy_file, "r")
f5_xz = h5.File(xz_file, "r")
f5_yz = h5.File(yz_file, "r")
data_xy = pytools.read_h5_array(f5_xy, var)
data_xz = pytools.read_h5_array(f5_xz, var)
data_yz = pytools.read_h5_array(f5_yz, var)
nx, ny, ns0 = np.shape(data_xy)
print(nx, ny, ns0)
nx, nz, ns1 = np.shape(data_xz)
print(nx, nz, ns1)
ny, nz, ns2 = np.shape(data_yz)
print(ny, nz, ns2)
# full data
#data = np.zeros((nx,ny,nz))
#xy
#data[:,:,0 ] = data_xy[:,:,0]
#data[:,:,-1] = data_xy[:,:,0]
##xz
#data[:,0, :] = data_xz[:,:,0]
#data[:,-1,:] = data_xz[:,:,0]
##yz
#data[0, :,:] = data_yz[:,:,0]
#data[-1,:,:] = data_yz[:,:,0]
# bare minimum (visible box sides)
data = np.zeros((nx, ny, 3))
data[:, :, 0] = data_xy[:, :, 0]
data[:, :, 1] = data_xz[:, :, 0]
#data[:,:,2] = data_yz[:,:,0]
return data
#if lap > 7500:
# break
if not (os.path.isfile(info['fields_file'])):
continue
print(info['fields_file'])
#print("lap {}".format(lap))
time = units.lap2time(lap) #, do_print=True)
#shift time with half packet step to accommodate initial positions
time -= 0.5
# read file
f5_fld = h5.File(info['fields_file'], 'r')
bx = pytools.read_h5_array(f5_fld, 'bx')
by = pytools.read_h5_array(f5_fld, 'by')
bz = pytools.read_h5_array(f5_fld, 'bz')
jx = pytools.read_h5_array(f5_fld, "jx")
jy = pytools.read_h5_array(f5_fld, "jy")
jz = pytools.read_h5_array(f5_fld, "jz")
ex = pytools.read_h5_array(f5_fld, "ex")
ey = pytools.read_h5_array(f5_fld, "ey")
ez = pytools.read_h5_array(f5_fld, "ez")
bperp2 = (bx * bx + by * by) #B_perp^2
bpar2 = (bz * bz) #B_par^2
eperp2 = (ex * ex + ey * ey) #E_perp^2
print(conf.outdir)
fname_fld = "flds"
fname_prtcls = "test-prtcls"
#args.lap
lap = 1000
box_offset = 0
for lap in [100, 1000, 2000]:
fields_file = conf.outdir + '/' + fname_fld + '_' + str(lap) + '.h5'
f5 = h5.File(fields_file, 'r')
data = pytools.read_h5_array(f5, 'jz')
#cut reflector out
data = data[6:, :, :]
#limit box length
xlen = 512
if lap <= 100:
xlen = 128
elif lap <= 1000:
xlen = 256 + 64
#data = data[0:256,:,:]
#data = data[0:512,:,:]
data = data[0:xlen, :, :]
def read_h5(outdir, fname_fld, var, lap):
fields_file = outdir + "/" + fname_fld + "_" + str(lap) + ".h5"
print(fields_file)
f5 = h5.File(fields_file, "r")
return pytools.read_h5_array(f5, var)
break
#print("lap {}".format(lap))
time = lap2time(lap, conf) #, do_print=True)
# read file
f5_fld = h5.File(info['fields_file'], 'r')
#bx = pytools.read_h5_array(f5_fld, 'bx')
#by = pytools.read_h5_array(f5_fld, 'by')
#bz = pytools.read_h5_array(f5_fld, 'bz')
#jx = pytools.read_h5_array(f5_fld, "jx")
#jy = pytools.read_h5_array(f5_fld, "jy")
#jz = pytools.read_h5_array(f5_fld, "jz")
ex = pytools.read_h5_array(f5_fld, "ex")
#ey = pytools.read_h5_array(f5_fld, "ey")
#ez = pytools.read_h5_array(f5_fld, "ez")
#print(np.shape(ex))
et[:, i] = ex[:, 0, 0] #take first slice
#end of this time step; close f5
f5_fld.close()
x = np.arange(0, conf.Nx * conf.NxMesh) / conf.c_omp
y = lap2time(np.arange(0, conf.Nt + 1, conf.interval), conf)
y *= np.sqrt(2)
#y /= 4.0
def build_edens(f5F):
ex = read_h5_array(f5F, "ex")
ey = read_h5_array(f5F, "ey")
ez = read_h5_array(f5F, "ez")
return ex*ex + ey*ey + ez*ez
def build_bdens(f5F):
bx = read_h5_array(f5F, "bx")
by = read_h5_array(f5F, "by")
bz = read_h5_array(f5F, "bz")
return bx*bx + by*by + bz*bz
def plot2d_shock_single(
ax,
var,
info,
title= None,
vmin = None,
vmax = None,
cmap = None,
clip = None,
):
#--------------------------------------------------
# unpack incoming arguments that modify defaults
args = {}
#general defaults
for key in default_values:
args[key] = default_values[key]
#overwrite with shock defaults
try:
for key in default_shock_values[var]:
args[key] = default_shock_values[var][key]
except:
pass
#finally, overwrite with user given values
for key in args:
try:
user_val = eval(key)
if not(user_val == None):
args[key] = user_val
print("overwriting {} key with {}".format(key, user_val))
except:
pass
print('--------------------------------------------------')
print("reading {}".format(info['fields_file']))
f5F = h5.File(info['fields_file'],'r')
# normal singular variables
if not(args['derived']):
val = read_h5_array(f5F, var)
# composite quantities
else:
print("building composite variable")
if var == "bdens":
val = build_bdens(f5F)
if var == "edens":
val = build_edens(f5F)
if var == "Gammae":
val = build_gamma(f5F)
#drop z direction
val = val[:,:,0]
print("corner000", val[0,0])
print("cornerNNN", val[-1,-1])
print("min val", np.min(val))
print("max val", np.max(val))
print("avg val", np.average(val))
#--------------------------------------------------
# get shape
nx, ny = np.shape(val)
print("nx={} ny={}".format(nx, ny))
walloc = 5.0
xmin =-(walloc)/info['skindepth']
ymin = 0.0
xmax = (nx-walloc)/info['skindepth']
ymax = ny/info['skindepth']
#if winsorize
if not(args['winsorize_min'] == None) or not(args['winsorize_max'] == None):
wvmin, wvmax = np.quantile(val, [args['winsorize_min'], 1.0-args['winsorize_max']])
if args['vmin'] == None:
args['vmin'] = wvmin
if args['vmax'] == None:
args['vmax'] = wvmax
else:
# else set vmin and vmax using normal min/max
if args['vmin'] == None:
args['vmin'] = np.min(val)
if args['vmax'] == None:
args['vmax'] = np.max(val)
# make color limits symmetric
if args['vsymmetric']:
vminmax = np.maximum( np.abs(args['vmin']), np.abs(args['vmax']) )
args['vmin'] = -vminmax
args['vmax'] = vminmax
# finally, re-check that user did not give vmin/vmax
args['vmin'] = vmin if not(vmin == None) else args['vmin']
args['vmax'] = vmax if not(vmax == None) else args['vmax']
#nor the project default
args['vmin'] = default_shock_values[var]['vmin'] if not(vmin == None) else args['vmin']
args['vmax'] = default_shock_values[var]['vmax'] if not(vmax == None) else args['vmax']
#--------------------------------------------------
# print all options
print("--- {} ---".format(var))
for key in args:
if not(key == None):
print(" setting {}: {}".format(key, args[key]))
#--------------------------------------------------
im = imshow(ax, val, xmin, xmax, ymin, ymax,
cmap = args['cmap'],
vmin = args['vmin'],
vmax = args['vmax'],
clip = args['clip'],
aspect=args['aspect'],
)
#cax, cb = colorbar(im)
#--------------------------------------------------
# colorbar
#ax.set_xlim((200.0, 600.0))
#ax.set_xlim((0.0, 400.0))
#ax.set_ylim((0.0, 64.0))
if do_dark:
plt.subplots_adjust(left=0.10, bottom=0.05, right=0.90, top=0.97)
else:
ax.set_xlabel(r"$x$ $(c/\omega_p)$")
ax.set_ylabel(r"$y$ $(c/\omega_p)$")
plt.subplots_adjust(left=0.15, bottom=0.10, right=0.87, top=0.97)
#axleft = 0.10
#axbottom = 0.06
#axright = 0.96
#axtop = 0.92
wskip = 0.0
pad = 0.01
pos = ax.get_position()
#print(pos)
axleft = pos.x0
axbottom = pos.y0
axright = pos.x0 + pos.width
axtop = pos.y0 + pos.height
print(axleft)
print(axbottom)
print(axright)
print(axtop)
#cax = plt.fig.add_axes([axleft+wskip, axtop+0.01, axright-axleft-2*wskip, 0.01])
cax = plt.fig.add_axes([axright+pad, axbottom+wskip, 0.01, axtop-axbottom-2*wskip])
cb = plt.fig.colorbar(im, cax=cax,
orientation='vertical',
ticklocation='right')
#cb.set_label(args['title'])
cax.text(1.0, 1.03, args['title'], transform=cax.transAxes)
#if do_dark:
# for axis in ['top', 'bottom', 'left', 'right']:
# cax.spines[axis].set_visible(False)
# #cax.spines[axis].set_linewidth(0)
# #cax.spines[axis].set_color('red')
#ax.set_title(title)
#plot2d_particles(ax, info, args)
if do_prtcls:
plot2d_particles(ax, info, args)
# if plotting with particles; add a tag to name
varp = var + '_p'
else:
varp = var
slap = str(info['lap']).rjust(4, '0')
if do_dark:
fname = fdir + varp+'_{}.png'.format(slap)
plt.savefig(fname)
else:
fname = fdir + varp+'_{}.pdf'.format(slap)
plt.savefig(fname)
cb.remove()
