Esempio n. 1
0
    def test2D(potential, field):
        potAccept2D = np.zeros((NX_2D + 1, NY_2D + 1))
        fieldAccept2D = np.zeros((NX_2D + 1, NY_2D + 1, 2))
        for i, j in np.ndindex(potAccept2D.shape):
            potAccept2D[i, j] = potential(X0_2D + DX_2D * i, Y0_2D + DY_2D * j)
            fieldAccept2D[i, j] = field(X0_2D + DX_2D * i, Y0_2D + DY_2D * j)

        # Boundary conditions
        V0x_2D = dirBC(potAccept2D[0, :])
        VNx_2D = dirBC(potAccept2D[NX_2D, :])
        V0y_2D = dirBC(potAccept2D[:, 0])
        VNy_2D = dirBC(potAccept2D[:, NY_2D])

        E0x_2D = neuBC(fieldAccept2D[0, :, 0])
        ENx_2D = neuBC(fieldAccept2D[NX_2D, :, 0])
        E0y_2D = neuBC(fieldAccept2D[:, 0, 1])
        ENy_2D = neuBC(fieldAccept2D[:, NY_2D, 1])

        for BC0x_2D in [V0x_2D, E0x_2D]:
            for BCNx_2D in [VNx_2D, ENx_2D]:
                for BC0y_2D in [V0y_2D, E0y_2D]:
                    for BCNy_2D in [VNy_2D]:  #,ENy_2D]:
                        for testType in ["direct", "jacobi", "gaussSeidel"]:
                            for cythonType in [True, False]:
                                if testType == "direct":
                                    potCalculated2D = esSolve.laplace2D(NX_2D,DX_2D,BC0x_2D,BCNx_2D, \
                                                                        NY_2D,DY_2D,BC0y_2D,BCNy_2D, \
                                                                        testType,cythonType)
                                else:
                                    potCalculated2D = esSolve.laplace2D(NX_2D,DX_2D,BC0x_2D,BCNx_2D, \
                                                                        NY_2D,DY_2D,BC0y_2D,BCNy_2D, \
                                                                        testType,relTol,absTol,cythonType)

                                test(potCalculated2D, potAccept2D)
Esempio n. 2
0
    def test1D(potential, field):
        potAccept1D = np.zeros(NX_1D + 1)
        fieldAccept1D = np.zeros((NX_1D + 1, 1))
        for i in range(NX_1D + 1):
            potAccept1D[i] = potential(X0_1D + DX_1D * i)
            fieldAccept1D[i] = field(X0_1D + DX_1D * i)

        # Boundary conditions
        V0_1D = dirBC(potAccept1D[0])
        VN_1D = dirBC(potAccept1D[NX_1D])

        E0_1D = neuBC(fieldAccept1D[0])
        EN_1D = neuBC(fieldAccept1D[NX_1D])

        for BC0_1D in [V0_1D, E0_1D]:
            for BCN_1D in [VN_1D]:  #,EN_1D]:
                for testType in ["direct", "jacobi", "gaussSeidel"]:
                    for cythonType in [True, False]:
                        if testType == "direct":
                            potCalculated1D = esSolve.laplace1D(NX_1D,DX_1D,BC0_1D,BCN_1D, \
                                                                testType,cythonType)
                        else:
                            potCalculated1D = esSolve.laplace1D(NX_1D,DX_1D,BC0_1D,BCN_1D, \
                                                                testType,relTol,absTol,cythonType)

                        test(potCalculated1D, potAccept1D)
Esempio n. 3
0
  def test2D(potential,field):
    potAccept2D   = np.zeros((NX_2D+1,NY_2D+1))
    fieldAccept2D = np.zeros((NX_2D+1,NY_2D+1,2))
    for i,j in np.ndindex(potAccept2D.shape):
      potAccept2D[i,j]   = potential(X0_2D+DX_2D*i,Y0_2D+DY_2D*j)
      fieldAccept2D[i,j] = field(    X0_2D+DX_2D*i,Y0_2D+DY_2D*j)

    # Boundary conditions
    V0x_2D = dirBC(potAccept2D[0,    :    ])
    VNx_2D = dirBC(potAccept2D[NX_2D,:    ])
    V0y_2D = dirBC(potAccept2D[:,    0    ])
    VNy_2D = dirBC(potAccept2D[:,    NY_2D])

    E0x_2D = neuBC(fieldAccept2D[0,    :,    0])
    ENx_2D = neuBC(fieldAccept2D[NX_2D,:,    0])
    E0y_2D = neuBC(fieldAccept2D[:,    0,    1])
    ENy_2D = neuBC(fieldAccept2D[:,    NY_2D,1])

    for BC0x_2D in [V0x_2D,E0x_2D]:
      for BCNx_2D in [VNx_2D,ENx_2D]:
        for BC0y_2D in [V0y_2D,E0y_2D]:
          for BCNy_2D in [VNy_2D]:#,ENy_2D]:
            for testType in ["direct","jacobi","gaussSeidel"]:
              for cythonType in [True,False]:
                if testType == "direct":
                  potCalculated2D = esSolve.laplace2D(NX_2D,DX_2D,BC0x_2D,BCNx_2D, \
                                                      NY_2D,DY_2D,BC0y_2D,BCNy_2D, \
                                                      testType,cythonType)
                else:
                  potCalculated2D = esSolve.laplace2D(NX_2D,DX_2D,BC0x_2D,BCNx_2D, \
                                                      NY_2D,DY_2D,BC0y_2D,BCNy_2D, \
                                                      testType,relTol,absTol,cythonType)

                test(potCalculated2D,potAccept2D)
Esempio n. 4
0
  def test1D(potential,field):
    potAccept1D   = np.zeros(NX_1D+1)
    fieldAccept1D = np.zeros((NX_1D+1,1))
    for i in range(NX_1D+1):
      potAccept1D[i]   = potential(X0_1D+DX_1D*i)
      fieldAccept1D[i] = field(    X0_1D+DX_1D*i)

    # Boundary conditions
    V0_1D = dirBC(potAccept1D[0    ])
    VN_1D = dirBC(potAccept1D[NX_1D])

    E0_1D = neuBC(fieldAccept1D[0    ])
    EN_1D = neuBC(fieldAccept1D[NX_1D])

    for BC0_1D in [V0_1D,E0_1D]:
      for BCN_1D in [VN_1D]:#,EN_1D]:
        for testType in ["direct","jacobi","gaussSeidel"]:
          for cythonType in [True,False]:
            if testType == "direct":
              potCalculated1D = esSolve.laplace1D(NX_1D,DX_1D,BC0_1D,BCN_1D, \
                                                  testType,cythonType)
            else:
              potCalculated1D = esSolve.laplace1D(NX_1D,DX_1D,BC0_1D,BCN_1D, \
                                                  testType,relTol,absTol,cythonType)

            test(potCalculated1D,potAccept1D)
Esempio n. 5
0
    def test3D(potential, field):
        potAccept3D = np.zeros((NX_3D + 1, NY_3D + 1, NZ_3D + 1))
        fieldAccept3D = np.zeros((NX_3D + 1, NY_3D + 1, NZ_3D + 1, 3))
        for i, j, k in np.ndindex(potAccept3D.shape):
            # consider using np.fromfunction here
            potAccept3D[i, j,
                        k] = potential(X0_3D + DX_3D * i, Y0_3D + DY_3D * j,
                                       Z0_3D + DZ_3D * k)
            fieldAccept3D[i, j,
                          k] = field(X0_3D + DX_3D * i, Y0_3D + DY_3D * j,
                                     Z0_3D + DZ_3D * k)

        # Boundary conditions
        V0x_3D = dirBC(potAccept3D[0, :, :])
        VNx_3D = dirBC(potAccept3D[NX_3D, :, :])
        V0y_3D = dirBC(potAccept3D[:, 0, :])
        VNy_3D = dirBC(potAccept3D[:, NY_3D, :])
        V0z_3D = dirBC(potAccept3D[:, :, 0])
        VNz_3D = dirBC(potAccept3D[:, :, NZ_3D])

        E0x_3D = neuBC(fieldAccept3D[0, :, :, 0])
        ENx_3D = neuBC(fieldAccept3D[NX_3D, :, :, 0])
        E0y_3D = neuBC(fieldAccept3D[:, 0, :, 1])
        ENy_3D = neuBC(fieldAccept3D[:, NY_3D, :, 1])
        E0z_3D = neuBC(fieldAccept3D[:, :, 0, 2])
        ENz_3D = neuBC(fieldAccept3D[:, :, NZ_3D, 2])

        for BC0x_3D in [V0x_3D, E0x_3D]:
            for BCNx_3D in [VNx_3D, ENx_3D]:
                for BC0y_3D in [V0y_3D, E0y_3D]:
                    for BCNy_3D in [VNy_3D, ENy_3D]:
                        for BC0z_3D in [V0z_3D, E0z_3D]:
                            for BCNz_3D in [VNz_3D]:  #,ENz_3D]:
                                for testType in [
                                        "direct", "jacobi", "gaussSeidel"
                                ]:
                                    for cythonType in [True, False]:
                                        if testType == "direct":
                                            potCalculated3D = esSolve.laplace3D(NX_3D,DX_3D,BC0x_3D,BCNx_3D, \
                                                                                NY_3D,DY_3D,BC0y_3D,BCNy_3D, \
                                                                                NZ_3D,DZ_3D,BC0z_3D,BCNz_3D, \
                                                                                testType,cythonType)
                                        else:
                                            potCalculated3D = esSolve.laplace3D(NX_3D,DX_3D,BC0x_3D,BCNx_3D, \
                                                                                NY_3D,DY_3D,BC0y_3D,BCNy_3D, \
                                                                                NZ_3D,DZ_3D,BC0z_3D,BCNz_3D, \
                                                                                testType,relTol,absTol,cythonType)

                                        test(potCalculated3D, potAccept3D)
Esempio n. 6
0
  def test3D(potential,field):
    potAccept3D   = np.zeros((NX_3D+1,NY_3D+1,NZ_3D+1))
    fieldAccept3D = np.zeros((NX_3D+1,NY_3D+1,NZ_3D+1,3))
    for i,j,k in np.ndindex(potAccept3D.shape):
      # consider using np.fromfunction here
      potAccept3D[i,j,k]   = potential(X0_3D+DX_3D*i,Y0_3D+DY_3D*j,Z0_3D+DZ_3D*k)
      fieldAccept3D[i,j,k] = field(    X0_3D+DX_3D*i,Y0_3D+DY_3D*j,Z0_3D+DZ_3D*k)

    # Boundary conditions
    V0x_3D = dirBC(potAccept3D[0,    :,    :    ])
    VNx_3D = dirBC(potAccept3D[NX_3D,:,    :    ])
    V0y_3D = dirBC(potAccept3D[:,    0,    :    ])
    VNy_3D = dirBC(potAccept3D[:,    NY_3D,:    ])
    V0z_3D = dirBC(potAccept3D[:,    :,    0    ])
    VNz_3D = dirBC(potAccept3D[:,    :,    NZ_3D])

    E0x_3D = neuBC(fieldAccept3D[0,    :,    :,    0])
    ENx_3D = neuBC(fieldAccept3D[NX_3D,:,    :,    0])
    E0y_3D = neuBC(fieldAccept3D[:,    0,    :,    1])
    ENy_3D = neuBC(fieldAccept3D[:,    NY_3D,:,    1])
    E0z_3D = neuBC(fieldAccept3D[:,    :,    0,    2])
    ENz_3D = neuBC(fieldAccept3D[:,    :,    NZ_3D,2])

    for BC0x_3D in [V0x_3D,E0x_3D]:
      for BCNx_3D in [VNx_3D,ENx_3D]:
        for BC0y_3D in [V0y_3D,E0y_3D]:
          for BCNy_3D in [VNy_3D,ENy_3D]:
            for BC0z_3D in [V0z_3D,E0z_3D]:
              for BCNz_3D in [VNz_3D]:#,ENz_3D]:
                for testType in ["direct","jacobi","gaussSeidel"]:
                  for cythonType in [True,False]:
                    if testType == "direct":
                      potCalculated3D = esSolve.laplace3D(NX_3D,DX_3D,BC0x_3D,BCNx_3D, \
                                                          NY_3D,DY_3D,BC0y_3D,BCNy_3D, \
                                                          NZ_3D,DZ_3D,BC0z_3D,BCNz_3D, \
                                                          testType,cythonType)
                    else:
                      potCalculated3D = esSolve.laplace3D(NX_3D,DX_3D,BC0x_3D,BCNx_3D, \
                                                          NY_3D,DY_3D,BC0y_3D,BCNy_3D, \
                                                          NZ_3D,DZ_3D,BC0z_3D,BCNz_3D, \
                                                          testType,relTol,absTol,cythonType)

                    test(potCalculated3D,potAccept3D)
Esempio n. 7
0
LX = 1.25
LY = 2.3
DX = LX / NX
DY = LY / NY
X0 = 1.0
Y0 = 2.0

amplitude = 2.0


def nonGroundedWall(Yindex):
    return amplitude * np.sin(np.pi * Yindex / NY)


# Boundary conditions
V0x = dirBC(np.zeros((NY + 1)))
VNx = dirBC(np.fromfunction(nonGroundedWall, (NY + 1, )))

V0y = dirBC(np.zeros((NX + 1)))
VNy = dirBC(np.zeros((NX + 1)))

start = time.clock()
potential_NoCython = esSolve.laplace2D(NX,
                                       DX,
                                       V0x,
                                       VNx,
                                       NY,
                                       DY,
                                       V0y,
                                       VNy,
                                       "gaussSeidel",
Esempio n. 8
0
import particleUtils
from particle import particle
import scipy.constants
from dirichlet import dirichlet as dirBC

# Grid
NX = 20
LX = 1.2
X0 = 1.5
DX = LX / NX

# Boundary conditions
deltaV_NR = 1.0e-3  # 1.0 mV
deltaV_R = 1.0e6  # 1.0 MV
V_min = 1.0
V0 = dirBC(V_min)
VN_NR = dirBC(V_min + deltaV_NR)
VN_R = dirBC(V_min + deltaV_R)

# Particle
mass = scipy.constants.electron_mass
charge = -scipy.constants.elementary_charge
X0_particle = X0
V0_particle = 0.0

electron_NR = particle(mass, charge, [X0_particle], [V0_particle])
electron_R_Rpush = particle(mass, charge, [X0_particle], [V0_particle])
electron_R_NRpush = particle(mass, charge, [X0_particle], [V0_particle])

# Time steps
T_NR = 0.99 * pow(-2.0 * mass * pow(LX, 2.0) / (charge * deltaV_NR), 0.5)
Esempio n. 9
0
NX = 25
NY = 30
LX = 1.25
LY = 2.3
DX = LX / NX
DY = LY / NY
X0 = 1.0
Y0 = 2.0

amplitude = 2.0

def nonGroundedWall(Yindex):
  return amplitude * np.sin(np.pi * Yindex / NY)

# Boundary conditions
V0x = dirBC(np.zeros((NY+1)))
VNx = dirBC(np.fromfunction(nonGroundedWall, (NY+1,)))

V0y = dirBC(np.zeros((NX+1)))
VNy = dirBC(np.zeros((NX+1)))

start = time.clock()

potential_1 = esSolve.laplace2D(NX,DX,V0x,VNx,NY,DY,V0y,VNy,"gaussSeidel",relTol=0.0,absTol=1.0)
potential_2 = esSolve.laplace2D(NX,DX,V0x,VNx,NY,DY,V0y,VNy,"gaussSeidel",relTol=0.0,absTol=0.5)
potential_3 = esSolve.laplace2D(NX,DX,V0x,VNx,NY,DY,V0y,VNy,"gaussSeidel",relTol=0.0,absTol=1.0e-3)

end = time.clock()

print("That took",round(end-start,1),"seconds.")
Esempio n. 10
0
import os
import sys
sys.path.append(os.path.dirname(os.path.realpath(__file__)) + '/../solvers')
import matplotlib.pyplot as plt
import esSolve
from dirichlet import dirichlet as dirBC

NX   = 100
LX   = 1.2

DX   = LX / NX

V0   = dirBC(1.0)
VN   = dirBC(2.0)

X0 = 1.5

pot1D = esSolve.laplace1D(NX,DX,V0,VN,"gaussSeidel",relTol=0.0,absTol=1.0e-3,useCython=False)

# could use X0 here to plot versus position instead of index
plt.plot(pot1D)
plt.show()
Esempio n. 11
0
import particleUtils
from particle import particle
import scipy.constants
from dirichlet import dirichlet as dirBC

# Grid
NX     = 20
LX     = 1.2
X0     = 1.5
DX     = LX / NX

# Boundary conditions
deltaV_NR = 1.0e-3 # 1.0 mV
deltaV_R  = 1.0e6  # 1.0 MV
V_min     = 1.0
V0        = dirBC(V_min)
VN_NR     = dirBC(V_min + deltaV_NR)
VN_R      = dirBC(V_min + deltaV_R)

# Particle
mass        = scipy.constants.electron_mass
charge      = -scipy.constants.elementary_charge
X0_particle = X0
V0_particle = 0.0

electron_NR       = particle(mass,charge,[X0_particle],[V0_particle])
electron_R_Rpush  = particle(mass,charge,[X0_particle],[V0_particle])
electron_R_NRpush = particle(mass,charge,[X0_particle],[V0_particle])

# Time steps
T_NR  = 0.99*pow(-2.0*mass*pow(LX,2.0)/(charge*deltaV_NR),0.5)