def SparsePoisson(self):
u = SparseGridEff3D(self.Lengths[0],self.Lengths[1],self.Lengths[2],self.n,interp_mode=self.imode,shape_mode=self.smode)
ct = 0
for i in range(1,self.n+1):
for j in range(1,self.n+2-i):
#p = self.np2grids[ct].reshape((2**(self.n+2-i-j),2**j,2**i)).transpose()
p = self.RegularGrid(2**i, 2**j, 2**(self.n+2-i-j))
up = SO.Poisson3Dperiodic(p,self.Lengths[0],self.Lengths[1],self.Lengths[2])
u.np2grids[ct] = up.transpose().reshape(2**(self.n+2))
ct += 1
ct = 0
for i in range(1,self.n):
for j in range(1,self.n+1-i):
#p = self.np1grids[ct].reshape((2**(self.n+1-i-j),2**j,2**i)).transpose()
p = self.RegularGrid(2**i,2**j,2**(self.n+1-i-j))
up = SO.Poisson3Dperiodic(p,self.Lengths[0],self.Lengths[1],self.Lengths[2])
u.np1grids[ct] = up.transpose().reshape(2**(self.n+1))
ct += 1
ct = 0
for i in range(1,self.n-1):
for j in range(1,self.n-i):
#p = self.ngrids[ct].reshape((2**(self.n-i-j),2**j,2**i)).transpose()
p = self.RegularGrid(2**i,2**j,2**(self.n-i-j))
up = SO.Poisson3Dperiodic(p,self.Lengths[0],self.Lengths[1],self.Lengths[2])
u.ngrids[ct] = up.transpose().reshape(2**(self.n))
ct += 1
return u
def resid(self,Lphinew,i):
phinew = SO.Poisson2Dperiodic(Lphinew,self.DomLenX,self.DomLenY)
Enew = np.zeros((self.ncelx,self.ncely,2))
Enew[:,:,1], Enew[:,:,0] = SO.SpectralDerivative2D(-1.*phinew,self.DomLenX,self.DomLenY)
self.Epar = self.IPVec(0.5*(Enew+self.E[i]))
vnew = self.v + self.dt*self.chrg*self.Epar
j = self.chrg*self.IGVec(0.5*(vnew+self.v))
return Lphinew - self.LaplacePhi - self.dt*self.DomLenX*self.DomLenY*self.Div(j)
def ComputeFieldPoisson(self, i):
self.phi[i] = SO.Poisson2Dperiodic(
self.chrg * (self.rho[i] - np.mean(self.rho[i])) * self.DomLenX *
self.DomLenY, self.DomLenX, self.DomLenY)
self.E[i, :, :,
1], self.E[i, :, :,
0] = SO.SpectralDerivative2D(-1. * self.phi[i],
self.DomLenX,
self.DomLenY)
def SparsePoisson(self):
u = SparseGridEff2D(self.Lx,self.Ly,self.n,interp_mode=self.imode,shape_mode=self.smode)
for i in range(self.n):
p = self.RegularGrid(self.ncelxp[i],self.ncelyp[i])
up = SO.Poisson2Dperiodic(p,self.Lx,self.Ly)
u.pgrids[i] = up.transpose().reshape(2**(self.n+1))
for i in range(self.n-1):
p = self.RegularGrid(self.ncelxm[i],self.ncelym[i])
up = SO.Poisson2Dperiodic(p,self.Lx,self.Ly)
u.mgrids[i] = up.transpose().reshape(2**self.n)
return u
def SparsePoisson(self):
u = SparseGridEff2D(self.Lx,self.Ly,self.n)
for i in range(self.n):
p = self.pgrids[i].reshape((2**(self.n-i),2**(i+1))).transpose()
up = SO.Poisson2Dperiodic(p,self.Lx,self.Ly)
u.pgrids[i] = up.transpose().reshape(2**(self.n+1))
for i in range(self.n-1):
p = self.mgrids[i].reshape((2**(self.n-i-1),2**(i+1))).transpose()
up = SO.Poisson2Dperiodic(p,self.Lx,self.Ly)
u.mgrids[i] = up.transpose().reshape(2**self.n)
return u
def SparseDerivative(self):
fx = SparseGridEff2D(self.Lx,self.Ly,self.n,interp_mode=self.imode,shape_mode=self.smode)
fy = SparseGridEff2D(self.Lx,self.Ly,self.n,interp_mode=self.imode,shape_mode=self.smode)
for i in range(self.n):
p = self.RegularGrid(self.ncelxp[i],self.ncelyp[i])
fyp, fxp = SO.SpectralDerivative2D(p,self.Lx,self.Ly)
fx.pgrids[i] = fxp.transpose().reshape(2**(self.n+1)); fy.pgrids[i] = fyp.transpose().reshape(2**(self.n+1))
for i in range(self.n-1):
p = self.RegularGrid(self.ncelxm[i],self.ncelym[i])
fyp, fxp = SO.SpectralDerivative2D(p,self.Lx,self.Ly)
fx.mgrids[i] = fxp.transpose().reshape(2**(self.n)); fy.mgrids[i] = fyp.transpose().reshape(2**(self.n))
return fx, fy
def SparseDerivative(self):
fx = SparseGridEff2D(self.Lx,self.Ly,self.n)
fy = SparseGridEff2D(self.Lx,self.Ly,self.n)
for i in range(self.n):
p = self.pgrids[i].reshape((2**(self.n-i),2**(i+1))).transpose()
fyp, fxp = SO.SpectralDerivative2D(p,self.Lx,self.Ly)
fx.pgrids[i] = fxp.transpose().reshape(2**(self.n+1)); fy.pgrids[i] = fyp.transpose().reshape(2**(self.n+1))
for i in range(self.n-1):
p = self.mgrids[i].reshape((2**(self.n-i-1),2**(i+1))).transpose()
fyp, fxp = SO.SpectralDerivative2D(p,self.Lx,self.Ly)
fx.mgrids[i] = fxp.transpose().reshape(2**(self.n)); fy.mgrids[i] = fyp.transpose().reshape(2**(self.n))
return fx, fy
def Initialize(self,N):
self.xi, self.vi, self.xe, self.ve = self.IDatGen(N,self.DomLen)
self.parwtse = np.ones_like(self.xe); self.parwtsi = np.ones_like(self.xi)
self.InterpGridHydros(0)
# self.phi[0] = SO.Poisson2Dperiodic(self.chrge*(self.rho[0] - np.mean(self.rho[0]))*self.DomLenX*self.DomLenY,self.DomLenX,self.DomLenY)
self.phi[0] = SO.Poisson1Dperiodic(self.rho[0],self.DomLen)
self.E[0,:] = SO.SpectralDerivative(-1.*self.phi[0],self.DomLen)
## Do an initial backward half-step to offset positions and velocities in time
self.Epare, self.Epari = self.IPVec(self.E[0])
dt_tmp = -1.*0.5*self.dt
self.vi += dt_tmp*self.chrgi*self.Epari
self.ve += dt_tmp*self.chrge*self.Epare
def ComputeFieldPoisson(self, i):
if self.field_solve == 'fast':
PoissRHS = self.chrg * (
self.rho[i] - self.rho[i].Mean()) * self.DomLenX * self.DomLenY
self.phi[i] = PoissRHS.SparsePoisson()
self.Ex[i], self.Ey[i] = self.phi[i].SparseDerivative()
self.Ex[i] = -1. * self.Ex[i]
self.Ey[i] = -1. * self.Ey[i]
else:
rhoreg = self.rho[i].RegularGrid(self.ncxf, self.ncyf)
self.phi[i] = SO.Poisson2Dperiodic(
self.chrg * (rhoreg - np.mean(rhoreg)) * self.DomLenX *
self.DomLenY, self.DomLenX, self.DomLenY)
self.Ey[i], self.Ex[i] = SO.SpectralDerivative2D(
-1. * self.phi[i], self.DomLenX, self.DomLenY)
def SparseDerivative(self):
fx = SparseGridEff3D(self.Lengths[0],self.Lengths[1],self.Lengths[2],self.n,interp_mode=self.imode,shape_mode=self.smode)
fy = SparseGridEff3D(self.Lengths[0],self.Lengths[1],self.Lengths[2],self.n,interp_mode=self.imode,shape_mode=self.smode)
fz = SparseGridEff3D(self.Lengths[0],self.Lengths[1],self.Lengths[2],self.n,interp_mode=self.imode,shape_mode=self.smode)
ct = 0
for i in range(1,self.n+1):
for j in range(1,self.n+2-i):
#p = self.np2grids[ct].reshape((2**(self.n+2-i-j),2**j,2**i)).transpose()
p = self.RegularGrid(2**i, 2**j, 2**(self.n+2-i-j))
fxp, fyp, fzp = SO.SpectralDerivative3D(p,self.Lengths[0],self.Lengths[1],self.Lengths[2])
fx.np2grids[ct] = fxp.transpose().reshape(2**(self.n+2))
fy.np2grids[ct] = fyp.transpose().reshape(2**(self.n+2))
fz.np2grids[ct] = fzp.transpose().reshape(2**(self.n+2))
ct += 1
ct = 0
for i in range(1,self.n):
for j in range(1,self.n+1-i):
#p = self.np1grids[ct].reshape((2**(self.n+1-i-j),2**j,2**i)).transpose()
p = self.RegularGrid(2**i,2**j,2**(self.n+1-i-j))
fxp, fyp, fzp = SO.SpectralDerivative3D(p,self.Lengths[0],self.Lengths[1],self.Lengths[2])
fx.np1grids[ct] = fxp.transpose().reshape(2**(self.n+1))
fy.np1grids[ct] = fyp.transpose().reshape(2**(self.n+1))
fz.np1grids[ct] = fzp.transpose().reshape(2**(self.n+1))
ct += 1
ct = 0
for i in range(1,self.n-1):
for j in range(1,self.n-i):
#p = self.ngrids[ct].reshape((2**(self.n-i-j),2**j,2**i)).transpose()
p = self.RegularGrid(2**i,2**j,2**(self.n-i-j))
fxp, fyp, fzp = SO.SpectralDerivative3D(p,self.Lengths[0],self.Lengths[1],self.Lengths[2])
fx.ngrids[ct] = fxp.transpose().reshape(2**(self.n))
fy.ngrids[ct] = fyp.transpose().reshape(2**(self.n))
fz.ngrids[ct] = fzp.transpose().reshape(2**(self.n))
ct += 1
return fx, fy, fz
def Initialize(self, N):
self.x, self.v = self.IDatGen(N, self.DomLenX, self.DomLenY)
self.InterpGridHydros(0)
self.phi[0] = SO.Poisson2Dperiodic(
self.chrg * (self.rho[0] - np.mean(self.rho[0])) * self.DomLenX *
self.DomLenY, self.DomLenX, self.DomLenY)
self.E[0, :, :,
1], self.E[0, :, :,
0] = SO.SpectralDerivative2D(-1. * self.phi[0],
self.DomLenX,
self.DomLenY)
## Do an initial backward half-step to offset positions and velocities in time
self.Epar = self.IPVec(self.E[0])
dt_tmp = -0.5 * self.dt
self.v += 0.5 * dt_tmp * self.chrg * self.Epar
t = self.chrg * self.B * dt_tmp / 2.0
s = 2.0 * t / (1.0 + t * t)
c = (1 - t * t) / (1 + t * t)
vnewx = self.v[:, 0] * c - self.v[:, 1] * s
vnewy = self.v[:, 0] * s + self.v[:, 1] * c
self.v[:, 0] = vnewx
self.v[:, 1] = vnewy
self.v += 0.5 * dt_tmp * self.chrg * self.Epar
def Initialize(self,N):
self.xi, self.vi, self.parwtsi, self.f0i, self.xe, self.ve, self.parwtsi, self.f0e = self.IDatGen(N,self.DomLenX,self.DomLenY, 5.)
self.InterpGridHydros(0)
# self.phi[0] = SO.Poisson2Dperiodic(self.chrge*(self.rho[0] - np.mean(self.rho[0]))*self.DomLenX*self.DomLenY,self.DomLenX,self.DomLenY)
self.phi[0] = SO.Poisson2Dperiodic(self.rho[0],self.DomLenX,self.DomLenY)
self.E[0,:,:,1], self.E[0,:,:,0] = SO.SpectralDerivative2D(-1.*self.phi[0],self.DomLenX,self.DomLenY)
## Do an initial backward half-step to offset positions and velocities in time
self.Epare, self.Epari = self.IPVec(self.E[0])
dt_tmp = -1.*0.5*self.dt
self.vi += 0.5*dt_tmp*self.chrgi*self.Epari
t = self.chrgi*self.B*dt_tmp/2.0; s = 2.0*t/(1.0 + t*t); c = (1-t*t)/(1+t*t)
vnewx = self.vi[:,0]*c - self.vi[:,1]*s
vnewy = self.vi[:,0]*s + self.vi[:,1]*c
self.vi[:,0] = vnewx; self.vi[:,1] = vnewy
self.vi += 0.5*dt_tmp*self.chrgi*self.Epari
self.ve += 0.5*dt_tmp*self.chrge*self.Epare
t = self.chrge*self.B*dt_tmp/2.0; s = 2.0*t/(1.0 + t*t); c = (1-t*t)/(1+t*t)
vnewx = self.ve[:,0]*c - self.ve[:,1]*s
vnewy = self.ve[:,0]*s + self.ve[:,1]*c
self.ve[:,0] = vnewx; self.ve[:,1] = vnewy
self.ve += 0.5*dt_tmp*self.chrge*self.Epare
def ComputeFieldPoisson(self,i):
self.phi = SO.Poisson3Dperiodic(self.chrg*(self.rho - np.mean(self.rho))*self.DomLenX*self.DomLenY*self.DomLenZ,self.DomLenX,self.DomLenY,self.DomLenZ)
self.E[:,:,:,0], self.E[:,:,:,1], self.E[:,:,:,2] = SO.SpectralDerivative3D(-1.*self.phi,self.DomLenX,self.DomLenY,self.DomLenZ)
def Initialize(self):
#self.x, self.v = self.IDatGen(N,self.DomLenX,self.DomLenY,self.DomLenZ)
self.InterpGridHydros(0)
self.phi = SO.Poisson3Dperiodic(self.chrg*(self.rho - np.mean(self.rho))*self.DomLenX*self.DomLenY*self.DomLenZ,self.DomLenX,self.DomLenY,self.DomLenZ)
self.E[:,:,:,0], self.E[:,:,:,1], self.E[:,:,:,2] = SO.SpectralDerivative3D(-1.*self.phi,self.DomLenX,self.DomLenY,self.DomLenZ)
def Div(self,F):
Fx_x, Fx_y, Fx_z = SO.SpectralDerivative3D(F[:,:,0],self.DomLenX,self.DomLenY,self.DomLenZ)
Fy_x, Fy_y, Fy_z = SO.SpectralDerivative3D(F[:,:,1],self.DomLenX,self.DomLenY,self.DomLenZ)
Fz_x, Fz_y, Fz_z = SO.SpectralDerivative3D(F[:,:,2],self.DomLenX,self.DomLenY,self.DomLenZ)
return Fx_x+Fy_y+Fz_z
def Div(self, F):
Fx_y, Fx_x = SO.SpectralDerivative2D(F[:, :, 0], self.DomLenX,
self.DomLenY)
Fy_y, Fy_x = SO.SpectralDerivative2D(F[:, :, 1], self.DomLenX,
self.DomLenY)
return Fx_x + Fy_y
