Example #1
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)
Example #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)
Example #3
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)
T_R = 0.99 * pow(-2.0 * mass * pow(LX, 2.0) / (charge * deltaV_R), 0.5)
steps = 100
DT_NR = T_NR / steps
DT_R = T_R / steps

# Solve for potential
pot1D_NR = esSolve.laplace1D(NX,
                             DX,
                             V0,
                             VN_NR,
                             "gaussSeidel",
                             relTol=0.0,
                             absTol=1.0e-3 * (deltaV_NR),
                             useCython=False)
pot1D_R = esSolve.laplace1D(NX,
                            DX,
                            V0,
                            VN_R,
                            "gaussSeidel",
                            relTol=0.0,
                            absTol=1.0e-3 * (deltaV_R),
                            useCython=False)

# Compute E = - grad V on grid
electricFieldOnGrid_NR = esSolve.potentialToElectricField(pot1D_NR, [DX])
electricFieldOnGrid_R = esSolve.potentialToElectricField(pot1D_R, [DX])
Example #4
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()
Example #5
0
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)
T_R   = 0.99*pow(-2.0*mass*pow(LX,2.0)/(charge*deltaV_R),0.5)
steps = 100
DT_NR = T_NR/steps
DT_R  = T_R/steps

# Solve for potential
pot1D_NR = esSolve.laplace1D(NX,DX,V0,VN_NR,"gaussSeidel",relTol=0.0,absTol=1.0e-3*(deltaV_NR),useCython=False)
pot1D_R  = esSolve.laplace1D(NX,DX,V0,VN_R,"gaussSeidel",relTol=0.0,absTol=1.0e-3*(deltaV_R),useCython=False)

# Compute E = - grad V on grid
electricFieldOnGrid_NR = esSolve.potentialToElectricField(pot1D_NR,[DX])
electricFieldOnGrid_R  = esSolve.potentialToElectricField(pot1D_R,[DX])
 
positions_NR        = [electron_NR.position[0]]
velocities_NR       = [electron_NR.velocity[0]]
positions_R_Rpush   = [electron_R_Rpush.position[0]]
velocities_R_Rpush  = [electron_R_Rpush.velocity[0]]
positions_R_NRpush  = [electron_R_NRpush.position[0]]
velocities_R_NRpush = [electron_R_NRpush.velocity[0]]

for step in xrange(steps+1):
  # Compute E at particle position