def test_linear_field_interpolation(self):
conf = Conf()
conf.Nx = 3
conf.Ny = 3
grid = pycorgi.twoD.Grid(conf.Nx, conf.Ny, conf.Nz)
grid.set_grid_lims(conf.xmin, conf.xmax, conf.ymin, conf.ymax)
loadTiles(grid, conf)
insert_em(grid, conf, linear_field)
inject(grid, filler_no_velocity, conf) #injecting plasma particles
##update boundaries
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
tile = grid.get_tile(i,j)
tile.update_boundaries(grid)
#interpolate fields
fintp = pypic.LinearInterpolator()
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
tile = grid.get_tile(i,j)
fintp.solve(tile)
#test results; avoid boundaries because they are cyclic
for i in range(1,conf.Nx-1):
for j in range(1,conf.Ny-1):
cid = grid.id(i,j)
c = grid.get_tile(cid)
container = c.get_container(0)
xx = container.loc(0)
yy = container.loc(1)
zz = container.loc(2)
for i, x in enumerate(xx):
#print(i)
ref = linear_field(xx[i], yy[i], zz[i]) #exact/true solution
ex_ref = ref + 0.0
ey_ref = ref + 1.0
ez_ref = ref + 2.0
#print("asserting {} {} {} vs {}".format(xx[i], yy[i], zz[i], ref))
self.assertAlmostEqual(container.ex(i), ex_ref, places=5)
self.assertAlmostEqual(container.ey(i), ey_ref, places=5)
self.assertAlmostEqual(container.ez(i), ez_ref, places=5)
bx_ref = ref + 3.0
by_ref = ref + 4.0
bz_ref = ref + 5.0
self.assertAlmostEqual(container.bx(i), bx_ref, places=5)
self.assertAlmostEqual(container.by(i), by_ref, places=5)
self.assertAlmostEqual(container.bz(i), bz_ref, places=5)
def test_const_field_interpolation(self):
conf = Conf()
grid = pycorgi.twoD.Grid(conf.Nx, conf.Ny, conf.Nz)
grid.set_grid_lims(conf.xmin, conf.xmax, conf.ymin, conf.ymax)
loadTiles(grid, conf)
insert_em(grid, conf, const_field)
inject(grid, filler_no_velocity, conf) #injecting plasma particles
##update boundaries
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
tile = grid.get_tile(i,j)
tile.update_boundaries(grid)
#interpolate fields
fintp = pypic.LinearInterpolator()
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
tile = grid.get_tile(i,j)
fintp.solve(tile)
#test results
for i in range(conf.Nx):
for j in range(conf.Ny):
cid = grid.id(i,j)
c = grid.get_tile(cid)
container = c.get_container(0)
xx = container.loc(0)
yy = container.loc(1)
zz = container.loc(2)
ux = container.vel(0)
uy = container.vel(1)
uz = container.vel(2)
for i, x in enumerate(xx):
#print(i)
ex_ref = 1.0
ey_ref = 2.0
ez_ref = 3.0
self.assertEqual(container.ex(i), ex_ref)
self.assertEqual(container.ey(i), ey_ref)
self.assertEqual(container.ez(i), ez_ref)
bx_ref = 4.0
by_ref = 5.0
bz_ref = 6.0
self.assertEqual(container.bx(i), bx_ref)
self.assertEqual(container.by(i), by_ref)
self.assertEqual(container.bz(i), bz_ref)
def test_test_particle_initialization(self):
conf = Conf()
conf.NxMesh = 3
conf.NyMesh = 3
conf.Nx = 3
conf.Ny = 3
conf.Ny = 1
conf.ppc = 1
conf.update_bbox()
grid = pycorgi.twoD.Grid(conf.Nx, conf.Ny, conf.Nz)
grid.set_grid_lims(conf.xmin, conf.xmax, conf.ymin, conf.ymax)
# this calls internally test particle addition
loadTiles(grid, conf)
conf = Configuration(args.conf_filename)
#grid = plasma.Grid(conf.Nx, conf.Ny)
grid = corgi.Grid(conf.Nx, conf.Ny, conf.Nz)
xmin = 0.0
xmax = conf.Nx * conf.NxMesh #XXX scaled length
ymin = 0.0
ymax = conf.Ny * conf.NyMesh
grid.set_grid_lims(xmin, xmax, ymin, ymax)
#init.loadMpiRandomly(grid)
init.loadMpiXStrides(grid)
loadTiles(grid, conf)
##################################################
# Path to be created
#if grid.master:
if True:
if not os.path.exists(conf.outdir):
os.makedirs(conf.outdir)
np.random.seed(1)
inject(grid, filler, conf) #injecting plasma particles
#insert_em(grid, conf, linear_field)
#static setup; communicate neighbor info once
grid.analyze_boundaries()
grid.send_tiles()
def test_filters_in_action(self):
#plt.fig = plt.figure(1, figsize=(4,6))
#plt.rc('font', family='serif', size=12)
#plt.rc('xtick')
#plt.rc('ytick')
#gs = plt.GridSpec(3, 1)
#
#axs = []
#for ai in range(3):
# axs.append( plt.subplot(gs[ai]) )
conf = Conf()
conf.Nx = 3
conf.Ny = 3
conf.Nz = 1
conf.NxMesh = 10
conf.NyMesh = 10
conf.NzMesh = 1
grid = pycorgi.twoD.Grid(conf.Nx, conf.Ny)
grid.set_grid_lims(conf.xmin, conf.xmax, conf.ymin, conf.ymax)
loadTiles(grid, conf)
insert_em(grid, conf, linear_ramp)
#inject(grid, filler_no_velocity, conf) #injecting plasma particles
flt = pytools.Filter(conf.NxMesh, conf.NyMesh)
flt.init_gaussian_kernel(4.0, 4.0)
flt.get_padded_current(grid.get_tile(1, 1), grid)
img = reshape(flt.get_image(), conf.NxMesh * 3, conf.NyMesh * 3)
#axs[0].imshow(img[conf.NxMesh:2*conf.NxMesh, conf.NyMesh:2*conf.NyMesh]) #, vmin=vmin, vmax=vmax)
#axs[0].imshow(img, vmin=0.0, vmax=100.0) #, vmin=vmin, vmax=vmax)
# reference array
data = np.zeros((conf.Nx * conf.NxMesh, conf.Ny * conf.NyMesh,
conf.Nz * conf.NzMesh, 3))
for cid in grid.get_tile_ids():
c = grid.get_tile(cid)
(i, j) = c.index
yee = c.get_yee(0)
for k in range(conf.NyMesh):
for q in range(conf.NxMesh):
for r in range(conf.NzMesh):
data[i * conf.NxMesh + q, j * conf.NyMesh + k,
0 * conf.NzMesh + r, 0] = yee.jx[q, k, r]
data[i * conf.NxMesh + q, j * conf.NyMesh + k,
0 * conf.NzMesh + r, 1] = yee.jy[q, k, r]
data[i * conf.NxMesh + q, j * conf.NyMesh + k,
0 * conf.NzMesh + r, 2] = yee.jz[q, k, r]
#img2 = data[:,:,0,0]
#axs[1].imshow(img2, vmin=0.0, vmax=100.0) #, vmin=vmin, vmax=vmax)
for i in range(0, 3 * conf.NxMesh):
for j in range(0, 3 * conf.NyMesh):
self.assertEqual(data[i, j, 0, 0], img[i, j]) #jx
flt.fft_image_forward()
flt.apply_kernel()
flt.fft_image_backward()
def test_current_deposit(self):
"""
test that current deposit of + and - particles with same x and v
produce zero current in total.
"""
try:
plt.fig = plt.figure(1, figsize=(5,7))
plt.rc('font', family='serif', size=12)
plt.rc('xtick')
plt.rc('ytick')
gs = plt.GridSpec(5, 1)
axs = []
for ai in range(5):
axs.append( plt.subplot(gs[ai]) )
except:
pass
conf = Conf()
conf.Nx = 3
conf.Ny = 3
conf.Nz = 1
conf.NxMesh = 10
conf.NyMesh = 10
conf.NzMesh = 1
conf.ppc = 1
conf.vel = 0.1
conf.Nspecies = 2
conf.me = -1.0 #electron mass-to-charge
conf.mi = 1.0 #ion mass-to-charge
conf.update_bbox()
grid = pycorgi.twoD.Grid(conf.Nx, conf.Ny, conf.Nz)
grid.set_grid_lims(conf.xmin, conf.xmax, conf.ymin, conf.ymax)
loadTiles(grid, conf)
#insert_em(grid, conf, const_field)
inject(grid, filler_xvel, conf) #injecting plasma particles
#pusher = pypic.BorisPusher()
#fintp = pypic.LinearInterpolator()
currint = pypic.ZigZag()
analyzer = pypic.Analyzator()
#deposit current
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
tile = grid.get_tile(i,j)
currint.solve(tile)
#exchange currents for the middle one only
#for j in [1]:
# for i in [1]:
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
tile = grid.get_tile(i,j)
tile.exchange_currents(grid)
try:
#plotNode(axs[0], grid, conf)
plot2dParticles(axs[0], grid, conf, downsample=0.1)
plot2dYee(axs[1], grid, conf, 'rho')
plot2dYee(axs[2], grid, conf, 'jx')
plot2dYee(axs[3], grid, conf, 'jy')
plot2dYee(axs[4], grid, conf, 'jz')
#saveVisz(-2, grid, conf)
except:
pass
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
c = grid.get_tile(i,j)
yee = c.get_yee(0)
for l in range(conf.NxMesh):
for m in range(conf.NyMesh):
self.assertAlmostEqual(yee.jx[l,m,0], 0.0, places=7 )
self.assertAlmostEqual(yee.jy[l,m,0], 0.0, places=7 )
self.assertAlmostEqual(yee.jz[l,m,0], 0.0, places=7 )
def test_current_exchange(self):
"""test that current exchange is producing hand-build array"""
#plt.fig = plt.figure(1, figsize=(5,7))
#plt.rc('font', family='serif', size=12)
#plt.rc('xtick')
#plt.rc('ytick')
#
#gs = plt.GridSpec(5, 1)
#
#axs = []
#for ai in range(5):
# axs.append( plt.subplot(gs[ai]) )
conf = Conf()
conf.Nx = 3
conf.Ny = 3
conf.Nz = 1
conf.NxMesh = 10
conf.NyMesh = 10
conf.NzMesh = 1
conf.ppc = 10
conf.vel = 0.1
conf.Nspecies = 2
conf.me =-1.0 #electron mass-to-charge
conf.mi = 1.0 #ion mass-to-charge
conf.update_bbox()
grid = pycorgi.twoD.Grid(conf.Nx, conf.Ny, conf.Nz)
grid.set_grid_lims(conf.xmin, conf.xmax, conf.ymin, conf.ymax)
loadTiles(grid, conf)
#insert_em(grid, conf, linear_field)
insert_em(grid, conf, const_field)
inject(grid, filler_xvel, conf) #injecting plasma particles
#pusher = pypic.BorisPusher()
#fintp = pypic.LinearInterpolator()
currint = pypic.ZigZag()
analyzer = pypic.Analyzator()
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
c = grid.get_tile(i,j)
yee = c.get_yee(0)
for l in range(-3, conf.NxMesh+3):
for m in range(-3,conf.NyMesh+3):
for n in range(-3,conf.NzMesh+3):
yee.jx[l,m,n] = 1.0
yee.jy[l,m,n] = 1.0
yee.jz[l,m,n] = 1.0
#deposit current
#for j in range(grid.get_Ny()):
# for i in range(grid.get_Nx()):
#for j in [1]:
# for i in [1]:
# tile = grid.get_tile(i,j)
# currint.solve(tile)
#exchange currents for the middle one only
for j in [1]:
for i in [1]:
tile = grid.get_tile(i,j)
tile.exchange_currents(grid)
#plotNode(axs[0], grid, conf)
##plot2dParticles(axs[0], grid, conf, downsample=0.1)
#plot2dYee(axs[1], grid, conf, 'rho')
#plot2dYee(axs[2], grid, conf, 'jx')
#plot2dYee(axs[3], grid, conf, 'jy')
#plot2dYee(axs[4], grid, conf, 'jz')
#saveVisz(-1, grid, conf)
# create reference 3 halo width array by hand
ref = np.ones((conf.NxMesh, conf.NyMesh))
ref[0:3, : ] = 2
ref[-3:10,: ] = 2
ref[:, 0:3, ] = 2
ref[:, -3:10] = 2
ref[0:3, 0:3 ] = 4
ref[7:10, 7:10] = 4
ref[0:3, 7:10] = 4
ref[7:10, 0:3 ] = 4
#print(ref)
for j in [1]:
for i in [1]:
c = grid.get_tile(i,j)
yee = c.get_yee(0)
for l in range(conf.NxMesh):
for m in range(conf.NyMesh):
self.assertEqual(ref[l,m], yee.jx[l,m,0] )
self.assertEqual(ref[l,m], yee.jy[l,m,0] )
self.assertEqual(ref[l,m], yee.jz[l,m,0] )
def skip_test_filters(self):
""" filter integration test with rest of the PIC functions"""
try:
plt.fig = plt.figure(1, figsize=(5,7))
plt.rc('font', family='serif', size=12)
plt.rc('xtick')
plt.rc('ytick')
gs = plt.GridSpec(8, 1)
axs = []
for ai in range(8):
axs.append( plt.subplot(gs[ai]) )
except:
pass
conf = Conf()
conf.Nx = 3
conf.Ny = 3
conf.Nz = 1
conf.NxMesh = 3
conf.NyMesh = 3
conf.NzMesh = 1
conf.ppc = 10
conf.vel = 0.1
conf.update_bbox()
grid = pycorgi.twoD.Grid(conf.Nx, conf.Ny, conf.Nz)
grid.set_grid_lims(conf.xmin, conf.xmax, conf.ymin, conf.ymax)
loadTiles(grid, conf)
#insert_em(grid, conf, linear_field)
insert_em(grid, conf, zero_field)
inject(grid, filler, conf) #injecting plasma particles
#inject(grid, filler_xvel, conf) #injecting plasma particles
#pusher = pypic.BorisPusher()
#fintp = pypic.LinearInterpolator()
currint = pypic.ZigZag()
analyzer = pypic.Analyzator()
flt = pytools.Filter(conf.NxMesh, conf.NyMesh)
flt.init_gaussian_kernel(1.0, 1.0)
#for lap in range(0, conf.Nt):
for lap in range(1):
#analyze
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
tile = grid.get_tile(i,j)
analyzer.analyze2d(tile)
#update boundaries
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
tile = grid.get_tile(i,j)
tile.update_boundaries(grid)
#deposit current
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
tile = grid.get_tile(i,j)
currint.solve(tile)
#exchange currents
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
tile = grid.get_tile(i,j)
tile.exchange_currents(grid)
try:
plotNode(axs[0], grid, conf)
#plot2dParticles(axs[0], grid, conf, downsample=0.1)
plot2dYee(axs[1], grid, conf, 'rho')
plot2dYee(axs[2], grid, conf, 'jx')
plot2dYee(axs[3], grid, conf, 'jy')
plot2dYee(axs[4], grid, conf, 'jz')
except:
pass
yee_ref = getYee2D(grid, conf)
#filter
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
print(" i j ({},{})".format(i,j))
tile = grid.get_tile(i,j)
flt.get_padded_current(tile, grid)
# fourier space filtering
flt.fft_image_forward()
flt.apply_kernel()
flt.fft_image_backward()
# direct filtering
#for fj in range(1):
# flt.direct_convolve_3point()
flt.set_current(tile)
#cycle new and temporary currents
for j in range(grid.get_Ny()):
for i in range(grid.get_Nx()):
tile = grid.get_tile(i,j)
tile.cycle_current()
yee = getYee2D(grid, conf)
try:
plot2dYee(axs[5], grid, conf, 'jx')
plot2dYee(axs[6], grid, conf, 'jy')
plot2dYee(axs[7], grid, conf, 'jz')
#saveVisz(lap, grid, conf)
except:
pass
for j in range(conf.Ny*conf.NyMesh):
for i in range(conf.Nx*conf.NxMesh):
#print("({},{})".format(i,j))
self.assertAlmostEqual( yee_ref['jx'][i,j], yee['jx'][i,j], places=6 )
self.assertAlmostEqual( yee_ref['jy'][i,j], yee['jy'][i,j], places=6 )
self.assertAlmostEqual( yee_ref['jz'][i,j], yee['jz'][i,j], places=6 )
def test_communication(self):
#plt.fig = plt.figure(1, figsize=(3,3))
#plt.rc('font', family='serif', size=12)
#plt.rc('xtick')
#plt.rc('ytick')
#
#gs = plt.GridSpec(1, 1)
#
#axs = []
#for ai in range(1):
# axs.append( plt.subplot(gs[ai]) )
conf = Conf()
conf.NxMesh = 3
conf.NyMesh = 3
conf.Nx = 3
conf.Ny = 3
conf.Ny = 1
conf.update_bbox()
conf.vel = 0.3
grid = pycorgi.twoD.Grid(conf.Nx, conf.Ny, conf.Nz)
grid.set_grid_lims(conf.xmin, conf.xmax, conf.ymin, conf.ymax)
loadTiles(grid, conf)
insert_em(grid, conf, const_field)
inject(grid, filler, conf) #injecting plasma particles
# push particles couple of times to make them leak into neighboring tiles
pusher = pypic.BorisPusher()
for lap in range(40):
#plot2dParticles(axs[0], grid, conf)
#saveVisz(lap, grid, conf)
for cid in grid.get_local_tiles():
tile = grid.get_tile(cid)
pusher.solve(tile)
##################################################
# communication
#update particle boundaries
for cid in grid.get_local_tiles():
tile = grid.get_tile(cid)
tile.check_outgoing_particles()
# global mpi exchange (independent)
for cid in grid.get_boundary_tiles():
tile = grid.get_tile(cid)
tile.pack_outgoing_particles()
# MPI global exchange
# transfer primary and extra data
grid.send_data(0) #(indepdendent)
grid.send_data(1) #(indepdendent)
grid.recv_data(0) #(indepdendent)
grid.recv_data(1) #(indepdendent)
grid.wait_data(0) #(indepdendent)
grid.wait_data(1) #(indepdendent)
# global unpacking (independent)
for cid in grid.get_virtual_tiles():
tile = grid.get_tile(cid)
tile.unpack_incoming_particles()
tile.check_outgoing_particles()
# transfer local + global
for cid in grid.get_local_tiles():
tile = grid.get_tile(cid)
tile.get_incoming_particles(grid)
# delete local transferred particles
for cid in grid.get_local_tiles():
tile = grid.get_tile(cid)
tile.delete_transferred_particles()
for cid in grid.get_virtual_tiles():
tile = grid.get_tile(cid)
tile.delete_all_particles()
# count how many particles we now have
n_particles = 0
for i in range(conf.Nx):
for j in range(conf.Ny):
for k in range(conf.Nz):
cid = grid.id(i,j)
c = grid.get_tile(cid)
container = c.get_container(0)
print("({},{},{}) has {}".format(i,j,k,len(container.loc(0))))
n_particles += len(container.loc(0))
#self.assertTrue( 0.0 <= container.loc(0) <= conf.xmax )
#self.assertTrue( 0.0 <= container.loc(1) <= conf.ymax )
#self.assertTrue( 0.0 <= container.loc(2) <= conf.zmax )
for prtcl in range(len(container.loc(0))):
print("{} {} {} maxs {} {} {} id {}/{}".format(
container.loc(0)[prtcl],
container.loc(1)[prtcl],
container.loc(2)[prtcl],
conf.xmax, conf.ymax, conf.zmax,
container.id(0)[prtcl],
container.id(1)[prtcl],
))
#print("prtcl {} x={} y={} z={} vx={} vy={} vz={}".format(
# prtcl,
# container.loc(0)[prtcl],
# container.loc(1)[prtcl],
# container.loc(2)[prtcl],
# container.vel(0)[prtcl],
# container.vel(1)[prtcl],
# container.vel(2)[prtcl]))
# check location
self.assertTrue( 0.0 <= container.loc(0)[prtcl] <= conf.xmax )
self.assertTrue( 0.0 <= container.loc(1)[prtcl] <= conf.ymax )
self.assertTrue( 0.0 <= container.loc(2)[prtcl] <= conf.zmax )
# check velocity
velx = container.vel(0)[prtcl]
vely = container.vel(1)[prtcl]
velz = container.vel(2)[prtcl]
vel = np.sqrt( velx*velx + vely*vely + velz*velz )
self.assertAlmostEqual( vel, conf.vel, places=6 )
tot_particles = (conf.Nx*conf.NxMesh *
conf.Ny*conf.NyMesh *
conf.Nz*conf.NzMesh *
conf.ppc)
#tot_particles =(conf.NxMesh *
# conf.NyMesh *
# conf.NzMesh *
# conf.ppc)
# assert that there is equal number of particles as we began with
self.assertEqual( tot_particles, n_particles )
