Beispiel #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)
Beispiel #2
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)
Beispiel #3
0

# 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",
                                       relTol=0.0,
                                       absTol=1.0e-3,
                                       useCython=False)
end = time.clock()
seconds_NoCython = end - start
print("No Cython took", round(seconds_NoCython, 1), "seconds.")

start = time.clock()
potential_Cython = esSolve.laplace2D(NX,
                                     DX,
                                     V0x,
                                     VNx,
                                     NY,
Beispiel #4
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.")

def plot2Darrays(arrays):
  fig = plt.figure()
  ax = fig.add_subplot(111, projection='3d')

  if len(arrays) == 1:
    X = np.linspace(X0, X0 + LX, num=arrays[0].shape[0])
    Y = np.linspace(Y0, Y0 + LY, num=arrays[0].shape[1])
    X, Y = np.meshgrid(X, Y, indexing='ij')
Beispiel #5
0
# 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,
Beispiel #6
0
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",relTol=0.0,absTol=1.0e-3,useCython=False)
end = time.clock()
seconds_NoCython = end - start
print("No Cython took",round(seconds_NoCython,1),"seconds.")

start = time.clock()
potential_Cython = esSolve.laplace2D(NX,DX,V0x,VNx,NY,DY,V0y,VNy,"gaussSeidel",relTol=0.0,absTol=1.0e-3,useCython=True)
end = time.clock()
seconds_Cython = end - start
print("Cython took",round(seconds_Cython,1),"seconds.")

print("Cython was",round(100.0*(1.0-seconds_Cython/seconds_NoCython),1),"percent faster.")