diff --git a/SimPEG/Tests/test_boundaryPoisson.py b/SimPEG/Tests/test_boundaryPoisson.py index e604c35b..6e10b827 100644 --- a/SimPEG/Tests/test_boundaryPoisson.py +++ b/SimPEG/Tests/test_boundaryPoisson.py @@ -20,9 +20,9 @@ class Test1D_InhomogeneousDirichlet(OrderTest): j_fun = lambda x: -np.pi*np.sin(np.pi*x) q_fun = lambda x: -(np.pi**2)*np.cos(np.pi*x) - xc_anal = phi(self.M.gridCC) - q_anal = q_fun(self.M.gridCC) - j_anal = j_fun(self.M.gridFx) + xc_ana = phi(self.M.gridCC) + q_ana = q_fun(self.M.gridCC) + j_ana = j_fun(self.M.gridFx) #TODO: Check where our boundary conditions are CCx or Nx # vec = self.M.vectorNx @@ -38,32 +38,32 @@ class Test1D_InhomogeneousDirichlet(OrderTest): V = Utils.sdiag(self.M.vol) G = -Pin.T*Pin*self.M.faceDiv.T * V D = self.M.faceDiv - j = McI*(G*xc_anal + P*phi_bc) + j = McI*(G*xc_ana + P*phi_bc) q = V*D*Pin.T*Pin*j + V*D*Pout.T*j_bc # Rearrange if we know q to solve for x A = V*D*Pin.T*Pin*McI*G - rhs = V*q_anal - V*D*Pin.T*Pin*McI*P*phi_bc - V*D*Pout.T*j_bc + rhs = V*q_ana - V*D*Pin.T*Pin*McI*P*phi_bc - V*D*Pout.T*j_bc # A = D*McI*G - # rhs = q_anal - D*McI*P*phi_bc + # rhs = q_ana - D*McI*P*phi_bc if self.myTest == 'j': - err = np.linalg.norm((j-j_anal), np.inf) + err = np.linalg.norm((j-j_ana), np.inf) elif self.myTest == 'q': - err = np.linalg.norm((q-V*q_anal), np.inf) + err = np.linalg.norm((q-V*q_ana), np.inf) elif self.myTest == 'xc': #TODO: fix the null space solver = SolverCG(A, maxiter=1000) xc = solver * (rhs) print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs) - err = np.linalg.norm((xc-xc_anal), np.inf) + err = np.linalg.norm((xc-xc_ana), np.inf) elif self.myTest == 'xcJ': #TODO: fix the null space xc = Solver(A) * (rhs) print np.linalg.norm(Utils.mkvc(A*xc) - rhs) j = McI*(G*xc + P*phi_bc) - err = np.linalg.norm((j-j_anal), np.inf) + err = np.linalg.norm((j-j_ana), np.inf) return err @@ -102,11 +102,11 @@ class Test2D_InhomogeneousDirichlet(OrderTest): j_funY = lambda x: -np.pi*np.cos(np.pi*x[:,0])*np.sin(np.pi*x[:,1]) q_fun = lambda x: -2*(np.pi**2)*phi(x) - xc_anal = phi(self.M.gridCC) - q_anal = q_fun(self.M.gridCC) - jX_anal = j_funX(self.M.gridFx) - jY_anal = j_funY(self.M.gridFy) - j_anal = np.r_[jX_anal,jY_anal] + xc_ana = phi(self.M.gridCC) + q_ana = q_fun(self.M.gridCC) + jX_ana = j_funX(self.M.gridFx) + jY_ana = j_funY(self.M.gridFy) + j_ana = np.r_[jX_ana,jY_ana] #TODO: Check where our boundary conditions are CCx or Nx # fxm,fxp,fym,fyp = self.M.faceBoundaryInd @@ -126,26 +126,26 @@ class Test2D_InhomogeneousDirichlet(OrderTest): McI = Utils.sdInv(self.M.getFaceInnerProduct()) G = -self.M.faceDiv.T * Utils.sdiag(self.M.vol) D = self.M.faceDiv - j = McI*(G*xc_anal + P*bc) + j = McI*(G*xc_ana + P*bc) q = D*j # self.M.plotImage(j, 'FxFy', showIt=True) # Rearrange if we know q to solve for x A = D*McI*G - rhs = q_anal - D*McI*P*bc + rhs = q_ana - D*McI*P*bc if self.myTest == 'j': - err = np.linalg.norm((j-j_anal), np.inf) + err = np.linalg.norm((j-j_ana), np.inf) elif self.myTest == 'q': - err = np.linalg.norm((q-q_anal), np.inf) + err = np.linalg.norm((q-q_ana), np.inf) elif self.myTest == 'xc': xc = Solver(A) * (rhs) - err = np.linalg.norm((xc-xc_anal), np.inf) + err = np.linalg.norm((xc-xc_ana), np.inf) elif self.myTest == 'xcJ': xc = Solver(A) * (rhs) j = McI*(G*xc + P*bc) - err = np.linalg.norm((j-j_anal), np.inf) + err = np.linalg.norm((j-j_ana), np.inf) return err @@ -182,9 +182,9 @@ class Test1D_InhomogeneousNeumann(OrderTest): j_fun = lambda x: np.pi*np.cos(np.pi*x) q_fun = lambda x: -(np.pi**2)*np.sin(np.pi*x) - xc_anal = phi(self.M.gridCC) - q_anal = q_fun(self.M.gridCC) - j_anal = j_fun(self.M.gridFx) + xc_ana = phi(self.M.gridCC) + q_ana = q_fun(self.M.gridCC) + j_ana = j_fun(self.M.gridFx) #TODO: Check where our boundary conditions are CCx or Nx vecN = self.M.vectorNx @@ -200,24 +200,24 @@ class Test1D_InhomogeneousNeumann(OrderTest): V = Utils.sdiag(self.M.vol) G = -Pin.T*Pin*self.M.faceDiv.T * V D = self.M.faceDiv - j = McI*(G*xc_anal + P*phi_bc) + j = McI*(G*xc_ana + P*phi_bc) q = V*D*Pin.T*Pin*j + V*D*Pout.T*j_bc # Rearrange if we know q to solve for x A = V*D*Pin.T*Pin*McI*G - rhs = V*q_anal - V*D*Pin.T*Pin*McI*P*phi_bc - V*D*Pout.T*j_bc + rhs = V*q_ana - V*D*Pin.T*Pin*McI*P*phi_bc - V*D*Pout.T*j_bc # A = D*McI*G - # rhs = q_anal - D*McI*P*phi_bc + # rhs = q_ana - D*McI*P*phi_bc if self.myTest == 'j': - err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf) + err = np.linalg.norm((Pin*j-Pin*j_ana), np.inf) elif self.myTest == 'q': - err = np.linalg.norm((q-V*q_anal), np.inf) + err = np.linalg.norm((q-V*q_ana), np.inf) elif self.myTest == 'xc': #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol = 1e-6) - err = np.linalg.norm((xc-xc_anal), np.inf) + err = np.linalg.norm((xc-xc_ana), np.inf) if info > 0: print 'Solve does not work well' print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs) @@ -225,7 +225,7 @@ class Test1D_InhomogeneousNeumann(OrderTest): #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol = 1e-6) j = McI*(G*xc + P*phi_bc) - err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf) + err = np.linalg.norm((Pin*j-Pin*j_ana), np.inf) if info > 0: print 'Solve does not work well' print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs) @@ -261,11 +261,11 @@ class Test2D_InhomogeneousNeumann(OrderTest): j_funY = lambda x: np.pi*np.sin(np.pi*x[:,0])*np.cos(np.pi*x[:,1]) q_fun = lambda x: -2*(np.pi**2)*phi(x) - xc_anal = phi(self.M.gridCC) - q_anal = q_fun(self.M.gridCC) - jX_anal = j_funX(self.M.gridFx) - jY_anal = j_funY(self.M.gridFy) - j_anal = np.r_[jX_anal,jY_anal] + xc_ana = phi(self.M.gridCC) + q_ana = q_fun(self.M.gridCC) + jX_ana = j_funX(self.M.gridFx) + jY_ana = j_funY(self.M.gridFy) + j_ana = np.r_[jX_ana,jY_ana] #TODO: Check where our boundary conditions are CCx or Nx @@ -290,21 +290,21 @@ class Test2D_InhomogeneousNeumann(OrderTest): V = Utils.sdiag(self.M.vol) G = -Pin.T*Pin*self.M.faceDiv.T * V D = self.M.faceDiv - j = McI*(G*xc_anal + P*phi_bc) + j = McI*(G*xc_ana + P*phi_bc) q = V*D*Pin.T*Pin*j + V*D*Pout.T*j_bc # Rearrange if we know q to solve for x A = V*D*Pin.T*Pin*McI*G - rhs = V*q_anal - V*D*Pin.T*Pin*McI*P*phi_bc - V*D*Pout.T*j_bc + rhs = V*q_ana - V*D*Pin.T*Pin*McI*P*phi_bc - V*D*Pout.T*j_bc if self.myTest == 'j': - err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf) + err = np.linalg.norm((Pin*j-Pin*j_ana), np.inf) elif self.myTest == 'q': - err = np.linalg.norm((q-V*q_anal), np.inf) + err = np.linalg.norm((q-V*q_ana), np.inf) elif self.myTest == 'xc': #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol = 1e-6) - err = np.linalg.norm((xc-xc_anal), np.inf) + err = np.linalg.norm((xc-xc_ana), np.inf) if info > 0: print 'Solve does not work well' print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs) @@ -312,7 +312,7 @@ class Test2D_InhomogeneousNeumann(OrderTest): #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol = 1e-6) j = McI*(G*xc + P*phi_bc) - err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf) + err = np.linalg.norm((Pin*j-Pin*j_ana), np.inf) if info > 0: print 'Solve does not work well' print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs) @@ -346,9 +346,9 @@ class Test1D_InhomogeneousMixed(OrderTest): j_fun = lambda x: -0.5*np.pi*np.sin(0.5*np.pi*x) q_fun = lambda x: -0.25*(np.pi**2)*np.cos(0.5*np.pi*x) - xc_anal = phi(self.M.gridCC) - q_anal = q_fun(self.M.gridCC) - j_anal = j_fun(self.M.gridFx) + xc_ana = phi(self.M.gridCC) + q_ana = q_fun(self.M.gridCC) + j_ana = j_fun(self.M.gridFx) #TODO: Check where our boundary conditions are CCx or Nx vecN = self.M.vectorNx @@ -364,24 +364,24 @@ class Test1D_InhomogeneousMixed(OrderTest): V = Utils.sdiag(self.M.vol) G = -Pin.T*Pin*self.M.faceDiv.T * V D = self.M.faceDiv - j = McI*(G*xc_anal + P*phi_bc) + j = McI*(G*xc_ana + P*phi_bc) q = V*D*Pin.T*Pin*j + V*D*Pout.T*j_bc # Rearrange if we know q to solve for x A = V*D*Pin.T*Pin*McI*G - rhs = V*q_anal - V*D*Pin.T*Pin*McI*P*phi_bc - V*D*Pout.T*j_bc + rhs = V*q_ana - V*D*Pin.T*Pin*McI*P*phi_bc - V*D*Pout.T*j_bc # A = D*McI*G - # rhs = q_anal - D*McI*P*phi_bc + # rhs = q_ana - D*McI*P*phi_bc if self.myTest == 'j': - err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf) + err = np.linalg.norm((Pin*j-Pin*j_ana), np.inf) elif self.myTest == 'q': - err = np.linalg.norm((q-V*q_anal), np.inf) + err = np.linalg.norm((q-V*q_ana), np.inf) elif self.myTest == 'xc': #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol = 1e-6) - err = np.linalg.norm((xc-xc_anal), np.inf) + err = np.linalg.norm((xc-xc_ana), np.inf) if info > 0: print 'Solve does not work well' print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs) @@ -389,7 +389,7 @@ class Test1D_InhomogeneousMixed(OrderTest): #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol = 1e-6) j = McI*(G*xc + P*phi_bc) - err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf) + err = np.linalg.norm((Pin*j-Pin*j_ana), np.inf) if info > 0: print 'Solve does not work well' print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs) @@ -425,11 +425,11 @@ class Test2D_InhomogeneousMixed(OrderTest): j_funY = lambda x: -0.5*np.pi*np.cos(0.5*np.pi*x[:,0])*np.sin(0.5*np.pi*x[:,1]) q_fun = lambda x: -2*((0.5*np.pi)**2)*phi(x) - xc_anal = phi(self.M.gridCC) - q_anal = q_fun(self.M.gridCC) - jX_anal = j_funX(self.M.gridFx) - jY_anal = j_funY(self.M.gridFy) - j_anal = np.r_[jX_anal,jY_anal] + xc_ana = phi(self.M.gridCC) + q_ana = q_fun(self.M.gridCC) + jX_ana = j_funX(self.M.gridFx) + jY_ana = j_funY(self.M.gridFy) + j_ana = np.r_[jX_ana,jY_ana] #TODO: Check where our boundary conditions are CCx or Nx @@ -454,21 +454,21 @@ class Test2D_InhomogeneousMixed(OrderTest): V = Utils.sdiag(self.M.vol) G = -Pin.T*Pin*self.M.faceDiv.T * V D = self.M.faceDiv - j = McI*(G*xc_anal + P*phi_bc) + j = McI*(G*xc_ana + P*phi_bc) q = V*D*Pin.T*Pin*j + V*D*Pout.T*j_bc # Rearrange if we know q to solve for x A = V*D*Pin.T*Pin*McI*G - rhs = V*q_anal - V*D*Pin.T*Pin*McI*P*phi_bc - V*D*Pout.T*j_bc + rhs = V*q_ana - V*D*Pin.T*Pin*McI*P*phi_bc - V*D*Pout.T*j_bc if self.myTest == 'j': - err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf) + err = np.linalg.norm((Pin*j-Pin*j_ana), np.inf) elif self.myTest == 'q': - err = np.linalg.norm((q-V*q_anal), np.inf) + err = np.linalg.norm((q-V*q_ana), np.inf) elif self.myTest == 'xc': #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol = 1e-6) - err = np.linalg.norm((xc-xc_anal), np.inf) + err = np.linalg.norm((xc-xc_ana), np.inf) if info > 0: print 'Solve does not work well' print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs) @@ -476,7 +476,7 @@ class Test2D_InhomogeneousMixed(OrderTest): #TODO: fix the null space xc, info = sp.linalg.minres(A, rhs, tol = 1e-6) j = McI*(G*xc + P*phi_bc) - err = np.linalg.norm((Pin*j-Pin*j_anal), np.inf) + err = np.linalg.norm((Pin*j-Pin*j_ana), np.inf) if info > 0: print 'Solve does not work well' print 'ACCURACY', np.linalg.norm(Utils.mkvc(A*xc) - rhs) diff --git a/SimPEG/Tests/test_cylMesh.py b/SimPEG/Tests/test_cylMesh.py index 5eaef428..eb0e6f42 100644 --- a/SimPEG/Tests/test_cylMesh.py +++ b/SimPEG/Tests/test_cylMesh.py @@ -160,9 +160,9 @@ class TestFaceDiv2D(OrderTest): F = self.M.projectFaceVector(Fc) divF = self.M.faceDiv.dot(F) - divF_anal = call3(sol, self.M.gridCC) + divF_ana = call3(sol, self.M.gridCC) - err = np.linalg.norm((divF-divF_anal), np.inf) + err = np.linalg.norm((divF-divF_ana), np.inf) return err def test_order(self): @@ -198,9 +198,9 @@ class TestEdgeCurl2D(OrderTest): Fc = cylF2(self.M, solR, solZ) Fc = np.c_[Fc[:,0],np.zeros(self.M.nF),Fc[:,1]] - curlE_anal = self.M.projectFaceVector(Fc) + curlE_ana = self.M.projectFaceVector(Fc) - err = np.linalg.norm((curlE-curlE_anal), np.inf) + err = np.linalg.norm((curlE-curlE_ana), np.inf) return err def test_order(self): diff --git a/SimPEG/Tests/test_interpolation.py b/SimPEG/Tests/test_interpolation.py index 7eb2050e..e3c0176d 100644 --- a/SimPEG/Tests/test_interpolation.py +++ b/SimPEG/Tests/test_interpolation.py @@ -34,7 +34,7 @@ class TestInterpolation1D(OrderTest): def getError(self): funX = lambda x: np.cos(2*np.pi*x) - anal = call1(funX, self.LOCS) + ana = call1(funX, self.LOCS) if 'CC' == self.type: grid = call1(funX, self.M.gridCC) @@ -43,7 +43,7 @@ class TestInterpolation1D(OrderTest): comp = self.M.getInterpolationMat(self.LOCS, self.type)*grid - err = np.linalg.norm((comp - anal), 2) + err = np.linalg.norm((comp - ana), 2) return err def test_orderCC(self): @@ -82,11 +82,11 @@ class TestInterpolation2d(OrderTest): funY = lambda x, y: np.cos(2*np.pi*x) if 'x' in self.type: - anal = call2(funX, self.LOCS) + ana = call2(funX, self.LOCS) elif 'y' in self.type: - anal = call2(funY, self.LOCS) + ana = call2(funY, self.LOCS) else: - anal = call2(funX, self.LOCS) + ana = call2(funX, self.LOCS) if 'F' in self.type: Fc = cartF2(self.M, funX, funY) @@ -101,7 +101,7 @@ class TestInterpolation2d(OrderTest): comp = self.M.getInterpolationMat(self.LOCS, self.type)*grid - err = np.linalg.norm((comp - anal), np.inf) + err = np.linalg.norm((comp - ana), np.inf) return err def test_orderCC(self): @@ -165,13 +165,13 @@ class TestInterpolation2dCyl(OrderTest): funY = lambda x, y: np.cos(2*np.pi*x) if 'x' in self.type: - anal = call2(funX, self.LOCS) + ana = call2(funX, self.LOCS) elif 'y' in self.type: - anal = call2(funY, self.LOCS) + ana = call2(funY, self.LOCS) elif 'z' in self.type: - anal = call2(funY, self.LOCS) + ana = call2(funY, self.LOCS) else: - anal = call2(funX, self.LOCS) + ana = call2(funX, self.LOCS) if 'Fx' == self.type: Fc = cartF2Cyl(self.M, funX, funY) @@ -192,7 +192,7 @@ class TestInterpolation2dCyl(OrderTest): comp = self.M.getInterpolationMat(self.LOCS, self.type)*grid - err = np.linalg.norm((comp - anal), np.inf) + err = np.linalg.norm((comp - ana), np.inf) return err def test_orderCC(self): @@ -234,13 +234,13 @@ class TestInterpolation3D(OrderTest): funZ = lambda x, y, z: np.cos(2*np.pi*x) if 'x' in self.type: - anal = call3(funX, self.LOCS) + ana = call3(funX, self.LOCS) elif 'y' in self.type: - anal = call3(funY, self.LOCS) + ana = call3(funY, self.LOCS) elif 'z' in self.type: - anal = call3(funZ, self.LOCS) + ana = call3(funZ, self.LOCS) else: - anal = call3(funX, self.LOCS) + ana = call3(funX, self.LOCS) if 'F' in self.type: Fc = cartF3(self.M, funX, funY, funZ) @@ -255,7 +255,7 @@ class TestInterpolation3D(OrderTest): comp = self.M.getInterpolationMat(self.LOCS, self.type)*grid - err = np.linalg.norm((comp - anal), np.inf) + err = np.linalg.norm((comp - ana), np.inf) return err def test_orderCC(self): diff --git a/SimPEG/Tests/test_operators.py b/SimPEG/Tests/test_operators.py index c15a44ac..9a465fcd 100644 --- a/SimPEG/Tests/test_operators.py +++ b/SimPEG/Tests/test_operators.py @@ -35,15 +35,15 @@ class TestCurl(OrderTest): E = self.M.projectEdgeVector(Ec) Fc = cartF3(self.M, solX, solY, solZ) - curlE_anal = self.M.projectFaceVector(Fc) + curlE_ana = self.M.projectFaceVector(Fc) curlE = self.M.edgeCurl.dot(E) if self._meshType == 'rotateLRM': # Really it is the integration we should be caring about: # So, let us look at the l2 norm. - err = np.linalg.norm(self.M.area*(curlE - curlE_anal), 2) + err = np.linalg.norm(self.M.area*(curlE - curlE_ana), 2) else: - err = np.linalg.norm((curlE - curlE_anal), np.inf) + err = np.linalg.norm((curlE - curlE_ana), np.inf) return err def test_order(self): @@ -63,8 +63,8 @@ class TestCurl2D(OrderTest): sol_curl2d = call2(sol, self.M.gridCC) Ec = cartE2(self.M, ex, ey) - sol_anal = self.M.edgeCurl*self.M.projectFaceVector(Ec) - err = np.linalg.norm((sol_curl2d-sol_anal), np.inf) + sol_ana = self.M.edgeCurl*self.M.projectFaceVector(Ec) + err = np.linalg.norm((sol_curl2d-sol_ana), np.inf) return err @@ -86,13 +86,13 @@ class TestCellGrad1D_InhomogeneousDirichlet(OrderTest): xc = sol(self.M.gridCC) - gradX_anal = fx(self.M.gridFx) + gradX_ana = fx(self.M.gridFx) bc = np.array([1,1]) self.M.setCellGradBC('dirichlet') gradX = self.M.cellGrad.dot(xc) + self.M.cellGradBC*bc - err = np.linalg.norm((gradX-gradX_anal), np.inf) + err = np.linalg.norm((gradX-gradX_ana), np.inf) return err @@ -114,12 +114,12 @@ class TestCellGrad2D_Dirichlet(OrderTest): xc = call2(sol, self.M.gridCC) Fc = cartF2(self.M, fx, fy) - gradX_anal = self.M.projectFaceVector(Fc) + gradX_ana = self.M.projectFaceVector(Fc) self.M.setCellGradBC('dirichlet') gradX = self.M.cellGrad.dot(xc) - err = np.linalg.norm((gradX-gradX_anal), np.inf) + err = np.linalg.norm((gradX-gradX_ana), np.inf) return err @@ -143,12 +143,12 @@ class TestCellGrad3D_Dirichlet(OrderTest): xc = call3(sol, self.M.gridCC) Fc = cartF3(self.M, fx, fy, fz) - gradX_anal = self.M.projectFaceVector(Fc) + gradX_ana = self.M.projectFaceVector(Fc) self.M.setCellGradBC('dirichlet') gradX = self.M.cellGrad.dot(xc) - err = np.linalg.norm((gradX-gradX_anal), np.inf) + err = np.linalg.norm((gradX-gradX_ana), np.inf) return err @@ -170,12 +170,12 @@ class TestCellGrad2D_Neumann(OrderTest): xc = call2(sol, self.M.gridCC) Fc = cartF2(self.M, fx, fy) - gradX_anal = self.M.projectFaceVector(Fc) + gradX_ana = self.M.projectFaceVector(Fc) self.M.setCellGradBC('neumann') gradX = self.M.cellGrad.dot(xc) - err = np.linalg.norm((gradX-gradX_anal), np.inf) + err = np.linalg.norm((gradX-gradX_ana), np.inf) return err @@ -199,12 +199,12 @@ class TestCellGrad3D_Neumann(OrderTest): xc = call3(sol, self.M.gridCC) Fc = cartF3(self.M, fx, fy, fz) - gradX_anal = self.M.projectFaceVector(Fc) + gradX_ana = self.M.projectFaceVector(Fc) self.M.setCellGradBC('neumann') gradX = self.M.cellGrad.dot(xc) - err = np.linalg.norm((gradX-gradX_anal), np.inf) + err = np.linalg.norm((gradX-gradX_ana), np.inf) return err @@ -227,14 +227,14 @@ class TestFaceDiv3D(OrderTest): F = self.M.projectFaceVector(Fc) divF = self.M.faceDiv.dot(F) - divF_anal = call3(sol, self.M.gridCC) + divF_ana = call3(sol, self.M.gridCC) if self._meshType == 'rotateLRM': # Really it is the integration we should be caring about: # So, let us look at the l2 norm. - err = np.linalg.norm(self.M.vol*(divF-divF_anal), 2) + err = np.linalg.norm(self.M.vol*(divF-divF_ana), 2) else: - err = np.linalg.norm((divF-divF_anal), np.inf) + err = np.linalg.norm((divF-divF_ana), np.inf) return err def test_order(self): @@ -257,9 +257,9 @@ class TestFaceDiv2D(OrderTest): F = self.M.projectFaceVector(Fc) divF = self.M.faceDiv.dot(F) - divF_anal = call2(sol, self.M.gridCC) + divF_ana = call2(sol, self.M.gridCC) - err = np.linalg.norm((divF-divF_anal), np.inf) + err = np.linalg.norm((divF-divF_ana), np.inf) return err @@ -283,9 +283,9 @@ class TestNodalGrad(OrderTest): gradE = self.M.nodalGrad.dot(phi) Ec = cartE3(self.M, solX, solY, solZ) - gradE_anal = self.M.projectEdgeVector(Ec) + gradE_ana = self.M.projectEdgeVector(Ec) - err = np.linalg.norm((gradE-gradE_anal), np.inf) + err = np.linalg.norm((gradE-gradE_ana), np.inf) return err @@ -309,9 +309,9 @@ class TestNodalGrad2D(OrderTest): gradE = self.M.nodalGrad.dot(phi) Ec = cartE2(self.M, solX, solY) - gradE_anal = self.M.projectEdgeVector(Ec) + gradE_ana = self.M.projectEdgeVector(Ec) - err = np.linalg.norm((gradE-gradE_anal), np.inf) + err = np.linalg.norm((gradE-gradE_ana), np.inf) return err