Full anisotropic tensor derivatives.

2026-09-09 11:34:26 +08:00 · 2014-03-03 11:01:12 -08:00
parent 8eaff94e48
commit 3dd54bc0e3
3 changed files with 186 additions and 63 deletions
@@ -5,45 +5,82 @@ from TestUtils import checkDerivative


 class TestInnerProductsDerivs(unittest.TestCase):
-    def setUp(self):
-        pass

-    def test_FaceIP_derivs_isotropic(self):
-        for d in range(3):
-            mesh = Mesh.TensorMesh([10,5,4][d:])
-            v = np.random.rand(mesh.nF)
-            def fun(sig):
-                M = mesh.getFaceInnerProduct(sig)
-                Md = mesh.getFaceInnerProductDeriv(sig)
-                return M*v, Utils.sdiag(v)*Md
-            sig = np.random.rand(mesh.nC)
-            passed = checkDerivative(fun, sig, plotIt=False)
-            self.assertTrue(passed)
+    def doTestFace(self, h, rep, vec, fast):
+        mesh = Mesh.TensorMesh(h)
+        v = np.random.rand(mesh.nF)
+        def fun(sig):
+            M = mesh.getFaceInnerProduct(sig)
+            if vec:
+                Md = mesh.getFaceInnerProductDeriv(sig, v=v, doFast=fast)
+                return M*v, Md
+            Md = mesh.getFaceInnerProductDeriv(sig, doFast=fast)
+            return M*v, Utils.sdiag(v)*Md
+        sig = np.random.rand(mesh.nC*rep)
+        return checkDerivative(fun, sig, num=5, plotIt=False)
+
+    def doTestEdge(self, h, rep, vec, fast):
+        mesh = Mesh.TensorMesh(h)
+        v = np.random.rand(mesh.nE)
+        def fun(sig):
+            M = mesh.getEdgeInnerProduct(sig)
+            if vec:
+                Md = mesh.getEdgeInnerProductDeriv(sig, v=v, doFast=fast)
+                return M*v, Md
+            Md = mesh.getEdgeInnerProductDeriv(sig, doFast=fast)
+            return M*v, Utils.sdiag(v)*Md
+        sig = np.random.rand(mesh.nC*rep)
+        return checkDerivative(fun, sig, num=5, plotIt=False)
+
+    def test_FaceIP_1D_isotropic(self):
+        self.assertTrue(self.doTestFace([10],1,True, False))
+    def test_FaceIP_2D_isotropic(self):
+        self.assertTrue(self.doTestFace([10, 4],1,True, False))
+    def test_FaceIP_3D_isotropic(self):
+        self.assertTrue(self.doTestFace([10, 4, 5],1,True, False))
+    def test_FaceIP_2D_anisotropic(self):
+        self.assertTrue(self.doTestFace([10, 4],2,True, False))
+    def test_FaceIP_3D_anisotropic(self):
+        self.assertTrue(self.doTestFace([10, 4, 5],3,True, False))
+    def test_FaceIP_2D_tensor(self):
+        self.assertTrue(self.doTestFace([10, 4],3,True, False))
+    def test_FaceIP_3D_tensor(self):
+        self.assertTrue(self.doTestFace([10, 4, 5],6,True, False))
+
+    def test_FaceIP_1D_isotropic_fast(self):
+        self.assertTrue(self.doTestFace([10],1, False, True))
+    def test_FaceIP_2D_isotropic_fast(self):
+        self.assertTrue(self.doTestFace([10, 4],1, False, True))
+    def test_FaceIP_3D_isotropic_fast(self):
+        self.assertTrue(self.doTestFace([10, 4, 5],1, False, True))
+    def test_FaceIP_2D_anisotropic_fast(self):
+        self.assertTrue(self.doTestFace([10, 4],2, False, True))
+    def test_FaceIP_3D_anisotropic_fast(self):
+        self.assertTrue(self.doTestFace([10, 4, 5],3, False, True))


-    def test_EdgeIP_derivs_isotropic(self):
-        for h in [[10,5],[10,5,4]]:
-            mesh = Mesh.TensorMesh(h)
-            v = np.random.rand(mesh.nE)
-            def fun(sig):
-                M = mesh.getEdgeInnerProduct(sig)
-                Md = mesh.getEdgeInnerProductDeriv(sig)
-                return M*v, Utils.sdiag(v)*Md
-            sig = np.random.rand(mesh.nC)
-            passed = checkDerivative(fun, sig, plotIt=False)
-            self.assertTrue(passed)
+    def test_EdgeIP_2D_isotropic(self):
+        self.assertTrue(self.doTestEdge([10, 4],1,True, False))
+    def test_EdgeIP_3D_isotropic(self):
+        self.assertTrue(self.doTestEdge([10, 4, 5],1,True, False))
+    def test_EdgeIP_2D_anisotropic(self):
+        self.assertTrue(self.doTestEdge([10, 4],2,True, False))
+    def test_EdgeIP_3D_anisotropic(self):
+        self.assertTrue(self.doTestEdge([10, 4, 5],3,True, False))
+    def test_EdgeIP_2D_tensor(self):
+        self.assertTrue(self.doTestEdge([10, 4],3,True, False))
+    def test_EdgeIP_3D_tensor(self):
+        self.assertTrue(self.doTestEdge([10, 4, 5],6,True, False))
+
+    def test_EdgeIP_2D_isotropic_fast(self):
+        self.assertTrue(self.doTestEdge([10, 4],1, False, True))
+    def test_EdgeIP_3D_isotropic_fast(self):
+        self.assertTrue(self.doTestEdge([10, 4, 5],1, False, True))
+    def test_EdgeIP_2D_anisotropic_fast(self):
+        self.assertTrue(self.doTestEdge([10, 4],2, False, True))
+    def test_EdgeIP_3D_anisotropic_fast(self):
+        self.assertTrue(self.doTestEdge([10, 4, 5],3, False, True))

-    def test_FaceIP_derivs_anisotropic(self):
-        for d in range(3):
-            mesh = Mesh.TensorMesh([10,5,4][d:])
-            v = np.random.rand(mesh.nF)
-            def fun(sig):
-                M = mesh.getFaceInnerProduct(sig)
-                Md = mesh.getFaceInnerProductDeriv(sig)
-                return M*v, Utils.sdiag(v)*Md
-            sig = np.random.rand(mesh.nC*mesh.dim)
-            passed = checkDerivative(fun, sig, plotIt=False)
-            self.assertTrue(passed)