Problem_b derivs and adjoint. Notation updates in Jvec and Jtvec.

simpegEM/Base.py

@@ -98,7 +98,7 @@ class BaseEMProblem(Problem.BaseProblem):
         """
         Deriv of MeSigma wrt sigma
         """ 
-        return self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma)(u)
+        return self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma)(u) * self.curModel.sigmaDeriv
     
 
     @property
@@ -111,7 +111,13 @@ class BaseEMProblem(Problem.BaseProblem):
         """
         Deriv of MeSigma wrt sigma
         """ 
-        return self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma, invMat=True)(u)
+        # TODO: only works for diagonal tensors. getEdgeInnerProductDeriv, invMat=True should be implemented in SimPEG
+
+        dMeSigmaI_dI = -self.MeSigmaI**2
+        dMe_dsig = self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma)(u)
+        dsig_dm = self.curModel.sigmaDeriv
+        return dMeSigmaI_dI * ( dMe_dsig * ( dsig_dm))
+        # return self.mesh.getEdgeInnerProductDeriv(self.curModel.sigma, invMat=True)(u)
 
 
     @property

simpegEM/FDEM/FDEM.py

@@ -34,46 +34,49 @@ class BaseFDEMProblem(BaseEMProblem):
 
         return F
 
-    def Jvec(self, m, v, u=None):
-        if u is None:
-           u = self.fields(m)
+    def Jvec(self, m, v, f=None):
+        if f is None:
+           f = self.fields(m) # rename to f?
 
         self.curModel = m
 
         Jv = self.dataPair(self.survey)
 
         for freq in self.survey.freqs:
-            A = self.getA(freq)
-            Ainv = self.Solver(A, **self.solverOpts)
+            dA_du = self.getA(freq) #
+            dA_duI = self.Solver(dA_du, **self.solverOpts) 
 
             for src in self.survey.getSrcByFreq(freq):
-                u_src = u[src, self._fieldType]
-                dF_dm = self.getADeriv(freq, u_src, v)
+                ftype = self._fieldType + 'Solution'
+                u_src = f[src, ftype]
+                dA_dm = self.getADeriv(freq, u_src, v)
                 dRHS_dm = self.getRHSDeriv(src, v)
                 if dRHS_dm is None:
-                    du_dm = Ainv * ( - dF_dm )
+                    du_dm = dA_duI * ( - dA_dm )
                 else:
-                    du_dm = Ainv * ( - dF_dm + dRHS_dm )
+                    du_dm = dA_duI * ( - dA_dm + dRHS_dm )
                 for rx in src.rxList:
-                    dAl_duFun = getattr(u, '_%sDeriv_u'%rx.projField, None)
-                    dAl_du = dAl_duFun(src, du_dm, adjoint=False)
-                    if dAl_du is not None:
-                        du_dm = dAl_du
+                    # df_duFun = u.deriv_u(rx.fieldsUsed, m)
+                    df_duFun = getattr(f, '_%sDeriv_u'%rx.projField, None)
+                    df_du = df_duFun(src, du_dm, adjoint=False)
+                    if df_du is not None:
+                        du_dm = df_du
 
-                    dAl_dmFun = getattr(u, '_%sDeriv_m'%rx.projField, None)
-                    dAl_dm = dAl_dmFun(src, v, adjoint=False)
-                    if dAl_dm is not None:
-                        du_dm += dAl_dm
+                    df_dmFun = getattr(f, '_%sDeriv_m'%rx.projField, None)
+                    df_dm = df_dmFun(src, v, adjoint=False)
+                    if df_dm is not None:
+                        du_dm += df_dm
+
+                    P = lambda v: rx.projectFieldsDeriv(src, self.mesh, f, v) # wrt u, also have wrt m
 
-                    P = lambda v: rx.projectFieldsDeriv(src, self.mesh, u, v)
 
                     Jv[src, rx] = P(du_dm)
 
         return Utils.mkvc(Jv)
 
-    def Jtvec(self, m, v, u=None):
-        if u is None:
-            u = self.fields(m)
+    def Jtvec(self, m, v, f=None): 
+        if f is None:
+            f = self.fields(m)
 
         self.curModel = m
 
@@ -81,7 +84,6 @@ class BaseFDEMProblem(BaseEMProblem):
         if not isinstance(v, self.dataPair):
             v = self.dataPair(self.survey, v)
 
-        # Jtv = np.zeros(self.PropMap.PropModel.nP)
         Jtv = np.zeros(m.size)
 
         for freq in self.survey.freqs:
@@ -89,31 +91,32 @@ class BaseFDEMProblem(BaseEMProblem):
             ATinv = self.Solver(AT, **self.solverOpts)
 
             for src in self.survey.getSrcByFreq(freq):
-                u_src = u[src, self._fieldType]
+                ftype = self._fieldType + 'Solution'
+                u_src = f[src, ftype]
 
                 for rx in src.rxList:
-                    PTv = rx.projectFieldsDeriv(src, self.mesh, u, v[src, rx], adjoint=True)
+                    PTv = rx.projectFieldsDeriv(src, self.mesh, f, v[src, rx], adjoint=True) # wrt u, need possibility wrt m
 
-                    dAl_duTFun = getattr(u, '_%sDeriv_u'%rx.projField, None)
-                    dAl_duT = dAl_duTFun(src, PTv, adjoint=True)
-                    if dAl_duT is not None:
-                        dF_duIT = ATinv * dAl_duT
+                    df_duTFun = getattr(f, '_%sDeriv_u'%rx.projField, None)
+                    df_duT = df_duTFun(src, PTv, adjoint=True)
+                    if df_duT is not None:
+                        dA_duIT = ATinv * df_duT
                     else:
-                        dF_duIT = ATinv * PTv
+                        dA_duIT = ATinv * PTv
 
-                    dF_dmT = self.getADeriv(freq, u_src, dF_duIT, adjoint=True)
+                    dA_dmT = self.getADeriv(freq, u_src, dA_duIT, adjoint=True)
 
-                    dRHS_dmT = self.getRHSDeriv(src, dF_duIT, adjoint=True)
+                    dRHS_dmT = self.getRHSDeriv(src, dA_duIT, adjoint=True)
 
                     if dRHS_dmT is None:
-                        du_dmT = - dF_dmT
+                        du_dmT = - dA_dmT
                     else:
-                        du_dmT = -dF_dmT + dRHS_dmT
+                        du_dmT = -dA_dmT + dRHS_dmT
 
-                    dAl_dmFun = getattr(u, '_%sDeriv_m'%rx.projField, None)
-                    dAlT_dm = dAl_dmFun(src, PTv, adjoint=True)
-                    if dAlT_dm is not None:
-                        du_dmT += dAlT_dm
+                    df_dmFun = getattr(f, '_%sDeriv_m'%rx.projField, None)
+                    dfT_dm = df_dmFun(src, PTv, adjoint=True)
+                    if dfT_dm is not None:
+                        du_dmT += dfT_dm
 
 
         #             fPTv = self.calcFields(PTv, freq, rx.projField, adjoint=True)
@@ -207,17 +210,14 @@ class ProblemFDEM_e(BaseFDEMProblem):
         return C.T*MfMui*C + 1j*omega(freq)*MeSigma
 
 
-    def getADeriv(self, freq, u, v, adjoint=False):
-        # sig = self.sigma
-        # dsig_dm = self.curModel.transformDeriv
-        # dMe_dsig = self.mesh.getEdgeInnerProductDeriv(sig)(u)
+    def getADeriv(self, freq, u, v, adjoint=False): # getADeriv_m 
         dsig_dm = self.curModel.sigmaDeriv
         dMe_dsig = self.MeSigmaDeriv(u)
 
         if adjoint:
-            return 1j * omega(freq) * ( dsig_dm.T * ( dMe_dsig.T * v ) )
+            return 1j * omega(freq) * ( dMe_dsig.T * v )
 
-        return 1j * omega(freq) * ( dMe_dsig * ( dsig_dm * v ) )
+        return 1j * omega(freq) * ( dMe_dsig * v )
 
     def getRHS(self, freq):
         """
@@ -234,7 +234,7 @@ class ProblemFDEM_e(BaseFDEMProblem):
 
         return RHS
 
-    def getRHSDeriv(self, src, v, adjoint=False):
+    def getRHSDeriv(self, src, v, adjoint=False): #getRHSDeriv_m
         C = self.mesh.edgeCurl
         MfMui = self.MfMui
         S_mDeriv, S_eDeriv = src.evalDeriv(self, adjoint)
@@ -298,21 +298,24 @@ class ProblemFDEM_b(BaseFDEMProblem):
 
         MfMui = self.MfMui
         C = self.mesh.edgeCurl
-        sig = self.sigma
-        dsig_dm = self.curModel.transformDeriv
-        dMeSigmaI_dI = self._dMeSigmaI_dI
+        MeSigmaIDeriv = self.MeSigmaIDeriv
+        vec = C.T*(MfMui*u)
 
-        vec = (C.T*(MfMui*u))
-        dMe_dsig = self.mesh.getEdgeInnerProductDeriv(sig)(vec)
+        MeSigmaIDeriv = MeSigmaIDeriv(vec)
+
+        # dMe_dsig = self.mesh.getEdgeInnerProductDeriv(sig)(vec)
 
         if adjoint:
             if self._makeASymmetric is True:
                 v = MfMui * v
-            return dsig_dm.T * ( dMe_dsig.T * ( dMeSigmaI_dI.T * ( C.T * v ) ) )
+            return MeSigmaIDeriv.T * (C.T * v)
+            # dsig_dm.T * ( dMe_dsig.T * ( dMeSigmaI_dI.T * ( C.T * v ) ) )
 
         if self._makeASymmetric is True:
-            return MfMui.T * ( C * ( dMeSigmaI_dI * ( dMe_dsig * ( dsig_dm * v ) ) ) )
-        return C * ( dMeSigmaI_dI * ( dMe_dsig * ( dsig_dm * v ) ) )
+            # return MfMui.T * ( C * ( dMeSigmaI_dI * ( dMe_dsig * ( dsig_dm * v ) ) ) )
+            return MfMui.T * ( C * ( MeSigmaIDeriv * v ) ) 
+        return C * ( MeSigmaIDeriv * v ) 
+        # C * ( dMeSigmaI_dI * ( dMe_dsig * ( dsig_dm * v ) ) )
 
 
     def getRHS(self, freq):
@@ -334,9 +337,58 @@ class ProblemFDEM_b(BaseFDEMProblem):
 
         return RHS
 
-    def getRHSDeriv(self, freq, v, adjoint=False):
-        raise NotImplementedError('getRHSDeriv not implemented yet')
-        return None
+    def getRHSDeriv(self, src, v, adjoint=False):
+        C = self.mesh.edgeCurl
+        S_m, S_e = self.getSourceTerm(src.freq)
+        MfMui = self.MfMui
+
+        if self._makeASymmetric and adjoint:
+            v = self.MfMui * v
+
+        if S_e is not None:
+            MeSigmaIDeriv = self.MeSigmaIDeriv(S_e)
+            if not adjoint:
+                RHSderiv = C * (MeSigmaIDeriv * v)
+            elif adjoint:
+                RHSderiv = MeSigmaIDeriv.T * (C.T * v)
+        else:
+            RHSderiv = None
+
+        S_mDeriv, S_eDeriv = src.evalDeriv(self, adjoint)
+        S_mDeriv, S_eDeriv = S_mDeriv(v), S_eDeriv(v)
+        if S_mDeriv is not None and S_eDeriv is not None:
+            if not adjoint:
+                SrcDeriv = S_mDeriv + C * (self.MeSigmaI * S_eDeriv)
+            elif adjoint:
+                SrcDeriv = S_mDeriv + Self.MeSigmaI.T * ( C.T * S_eDeriv)
+        elif S_mDeriv is not None:
+            SrcDeriv = S_mDeriv
+        elif S_eDeriv is not None:
+            if not adjoint:
+                SrcDeriv = C * (self.MeSigmaI * S_eDeriv)
+            elif adjoint:
+                SrcDeriv = self.MeSigmaI.T * ( C.T * S_eDeriv)
+        else: 
+            SrcDeriv = None
+
+        if RHSderiv is not None and SrcDeriv is not None:
+            RHSderiv += SrcDeriv
+        # elif RHSderiv is not None:
+        #     # if self._makeASymmetric is True:
+        #     #     return MfMui.T * RHSderiv
+        #     # return RHSderiv
+        elif SrcDeriv is not None:
+            # if self._makeASymmetric is True:
+            #     return MfMui.T * SrcDeriv
+            RHSderiv = SrcDeriv
+        # else:
+        #     return None
+
+        if self._makeASymmetric is True and not adjoint:
+            return MfMui.T * RHSderiv
+            # elif adjoint:
+            #     return 
+        return RHSderiv
 
 
 

simpegEM/FDEM/FieldsFDEM.py

@@ -25,6 +25,10 @@ class FieldsFDEM_e(FieldsFDEM):
     def startup(self):
         self._edgeCurl = self.survey.prob.mesh.edgeCurl
 
+    # def getDeriv_u(self, fieldsList, src, v, adjoint=False):
+
+    # def getDeriv_m(self, fieldsList, src, v, adjoint=False):
+
     def _ePrimary(self, eSolution, srcList):
         ePrimary = np.zeros_like(eSolution)
         for i, src in enumerate(srcList):
@@ -43,6 +47,7 @@ class FieldsFDEM_e(FieldsFDEM):
         return None
 
     def _eDeriv_m(self, src, v, adjoint = False):
+        # assuming primary does not depend on the model
         return None
 
     def _bPrimary(self, eSolution, srcList):
@@ -106,6 +111,7 @@ class FieldsFDEM_b(FieldsFDEM):
         self._edgeCurl = self.survey.prob.mesh.edgeCurl
         self._MeSigmaI = self.survey.prob.MeSigmaI
         self._MfMui = self.survey.prob.MfMui
+        self._MeSigmaIDeriv = self.survey.prob.MeSigmaIDeriv
 
     def _bPrimary(self, bSolution, srcList):
         bPrimary = np.zeros_like(bSolution)
@@ -121,6 +127,13 @@ class FieldsFDEM_b(FieldsFDEM):
     def _b(self, bSolution, srcList):
         return self._bPrimary(bSolution, srcList) + self._bSecondary(bSolution, srcList)  
 
+    def _bDeriv_u(self, src, v, adjoint=False):
+        return None
+
+    def _bDeriv_m(self, src, v, adjoint=False):
+        # assuming primary does not depend on the model
+        return None
+
     def _ePrimary(self, bSolution, srcList):
         ePrimary = np.zeros([self._edgeCurl.shape[1],bSolution.shape[1]],dtype = complex)
         for i,src in enumerate(srcList):
@@ -135,21 +148,44 @@ class FieldsFDEM_b(FieldsFDEM):
             _,S_e = src.eval(self.survey.prob)
             if S_e is not None:
                 e += -self._MeSigmaI*S_e
-
         return e
 
+    def _eSecondaryDeriv_u(self, src, v, adjoint=False):
+        if not adjoint:
+            return self._MeSigmaI * ( self._edgeCurl.T * ( self._MfMui * v) ) 
+        else:
+            return self._MfMui.T * (self._edgeCurl * (self._MeSigmaI.T * v))
+
+    def _eSecondaryDeriv_m(self, src, v, adjoint=False):
+        bsol = self[[src],'bSolution']
+        _,S_e = src.eval(self.survey.prob)
+
+        w = self._edgeCurl.T * (self._MfMui * bsol)
+        if S_e is not None:
+            w += -S_e
+
+        if not adjoint:
+            de_dm = self._MeSigmaIDeriv(w) * v
+        elif adjoint: 
+            de_dm = self._MeSigmaIDeriv(w).T * v
+
+        _, S_eDeriv = src.evalDeriv(self.survey.prob, adjoint)
+        Se_Deriv = S_eDeriv(v)
+
+        if Se_Deriv is not None:
+            de_dm += -self._MeSigmaI * Se_Deriv
+
+        return de_dm
+
     def _e(self, bSolution, srcList):
         return self._ePrimary(bSolution, srcList) + self._eSecondary(bSolution, srcList)
 
-    def _eDeriv(self, bSolution, srcList, v, adjoint=False):
-        raise NotImplementedError('Fields Derivs Not Implemented Yet')
-        _,S_eDeriv = src.evalDeriv(self.survey.prob, adjoint)
-        S_eDeriv = S_eDeriv(v)
+    def _eDeriv_u(self, src, v, adjoint=False):
+        return self._eSecondaryDeriv_u(src, v, adjoint)
 
-        if S_eDeriv is None:
-            return None
-        else:
-            return -S_eDeriv
+    def _eDeriv_m(self, src, v, adjoint=False):
+        # assuming primary doesn't depend on model
+        return self._eSecondaryDeriv_m(src, v, adjoint)
 
 
 class FieldsFDEM_j(FieldsFDEM):

simpegEM/FDEM/SurveyFDEM.py

@@ -138,7 +138,7 @@ class SrcFDEM_RawVec_e(SrcFDEM):
     """
 
     def __init__(self, rxList, freq, S_e):
-        self._S_e = np.array(S_e,dtype=complex)
+        self._S_e = np.array(S_e,dtype=float)
         self.freq = float(freq)
         SrcFDEM.__init__(self, rxList)
 
@@ -156,7 +156,7 @@ class SrcFDEM_RawVec_m(SrcFDEM):
     """
 
     def __init__(self, rxList, freq, S_m):
-        self._S_m = np.array(S_m,dtype=complex)
+        self._S_m = np.array(S_m,dtype=float)
         self.freq = float(freq)
         SrcFDEM.__init__(self, rxList)
 
@@ -174,8 +174,8 @@ class SrcFDEM_RawVec(SrcFDEM):
         :param rxList: receiver list
     """
     def __init__(self, rxList, freq, S_m, S_e):
-        self._S_m = np.array(S_m,dtype=complex)
-        self._S_e = np.array(S_e,dtype=complex)
+        self._S_m = np.array(S_m,dtype=float)
+        self._S_e = np.array(S_e,dtype=float)
         self.freq = float(freq)
         SrcFDEM.__init__(self, rxList)
 

simpegEM/Tests/test_FDEM.py

@@ -6,7 +6,7 @@ from scipy.constants import mu_0
 import copy
 
 testDerivs = True
-testCrossCheck = False
+testCrossCheck = True
 testAdjoint = True
 testEB = True
 testHJ = False
@@ -84,8 +84,8 @@ def adjointTest(fdemType, comp):
     # print prb.PropMap.PropModel.nP
     w = np.random.rand(prb.mesh.nC)
 
-    vJw = v.dot(prb.Jvec(m, w, u=u))
-    wJtv = w.dot(prb.Jtvec(m, v, u=u))
+    vJw = v.dot(prb.Jvec(m, w, u))
+    wJtv = w.dot(prb.Jtvec(m, v, u))
     tol = np.max([TOL*(10**int(np.log10(np.abs(vJw)))),FLR]) 
     print vJw, wJtv, vJw - wJtv, tol, np.abs(vJw - wJtv) < tol
     return np.abs(vJw - wJtv) < tol
@@ -165,54 +165,55 @@ class FDEM_DerivTests(unittest.TestCase):
         if testEB:
             def test_Jvec_exr_Eform(self):
                 self.assertTrue(derivTest('e', 'exr'))
-            # def test_Jvec_exr_Bform(self):
-            #     self.assertTrue(derivTest('b', 'exr'))
             def test_Jvec_eyr_Eform(self):
                 self.assertTrue(derivTest('e', 'eyr'))
-            # def test_Jvec_eyr_Bform(self):
-            #     self.assertTrue(derivTest('b', 'eyr'))
             def test_Jvec_ezr_Eform(self):
                 self.assertTrue(derivTest('e', 'ezr'))
-            # def test_Jvec_ezr_Bform(self):
-            #     self.assertTrue(derivTest('b', 'ezr'))
             def test_Jvec_exi_Eform(self):
                 self.assertTrue(derivTest('e', 'exi'))
-            # def test_Jvec_exi_Bform(self):
-            #     self.assertTrue(derivTest('b', 'exi'))
             def test_Jvec_eyi_Eform(self):
                 self.assertTrue(derivTest('e', 'eyi'))
-            # def test_Jvec_eyi_Bform(self):
-            #     self.assertTrue(derivTest('b', 'eyi'))
             def test_Jvec_ezi_Eform(self):
                 self.assertTrue(derivTest('e', 'ezi'))
-            # def test_Jvec_ezi_Bform(self):
-            #     self.assertTrue(derivTest('b', 'ezi'))
-
 
             def test_Jvec_bxr_Eform(self):
                 self.assertTrue(derivTest('e', 'bxr'))
-            # def test_Jvec_bxr_Bform(self):
-            #     self.assertTrue(derivTest('b', 'bxr'))
             def test_Jvec_byr_Eform(self):
                 self.assertTrue(derivTest('e', 'byr'))
-            # def test_Jvec_byr_Bform(self):
-            #     self.assertTrue(derivTest('b', 'byr'))
             def test_Jvec_bzr_Eform(self):
                 self.assertTrue(derivTest('e', 'bzr'))
-            # def test_Jvec_bzr_Bform(self):
-            #     self.assertTrue(derivTest('b', 'bzr'))
             def test_Jvec_bxi_Eform(self):
                 self.assertTrue(derivTest('e', 'bxi'))
-            # def test_Jvec_bxi_Bform(self):
-            #     self.assertTrue(derivTest('b', 'bxi'))
             def test_Jvec_byi_Eform(self):
                 self.assertTrue(derivTest('e', 'byi'))
-            # def test_Jvec_byi_Bform(self):
-            #     self.assertTrue(derivTest('b', 'byi'))
             def test_Jvec_bzi_Eform(self):
                 self.assertTrue(derivTest('e', 'bzi'))
-            # def test_Jvec_bzi_Bform(self):
-            #     self.assertTrue(derivTest('b', 'bzi'))
+
+            def test_Jvec_exr_Bform(self):
+                self.assertTrue(derivTest('b', 'exr'))
+            def test_Jvec_eyr_Bform(self):
+                self.assertTrue(derivTest('b', 'eyr'))
+            def test_Jvec_ezr_Bform(self):
+                self.assertTrue(derivTest('b', 'ezr'))
+            def test_Jvec_exi_Bform(self):
+                self.assertTrue(derivTest('b', 'exi'))
+            def test_Jvec_eyi_Bform(self):
+                self.assertTrue(derivTest('b', 'eyi'))
+            def test_Jvec_ezi_Bform(self):
+                self.assertTrue(derivTest('b', 'ezi'))
+
+            def test_Jvec_bxr_Bform(self):
+                self.assertTrue(derivTest('b', 'bxr'))
+            def test_Jvec_byr_Bform(self):
+                self.assertTrue(derivTest('b', 'byr'))
+            def test_Jvec_bzr_Bform(self):
+                self.assertTrue(derivTest('b', 'bzr'))
+            def test_Jvec_bxi_Bform(self):
+                self.assertTrue(derivTest('b', 'bxi'))
+            def test_Jvec_byi_Bform(self):
+                self.assertTrue(derivTest('b', 'byi'))
+            def test_Jvec_bzi_Bform(self):
+                self.assertTrue(derivTest('b', 'bzi'))
 
         if testHJ: 
             def test_Jvec_jxr_Jform(self):
@@ -272,53 +273,55 @@ class FDEM_DerivTests(unittest.TestCase):
         if testEB:
             def test_Jtvec_adjointTest_exr_Eform(self):
                 self.assertTrue(adjointTest('e', 'exr'))
-            # def test_Jtvec_adjointTest_exr_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'exr'))
             def test_Jtvec_adjointTest_eyr_Eform(self):
                 self.assertTrue(adjointTest('e', 'eyr'))
-            # def test_Jtvec_adjointTest_eyr_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'eyr'))
             def test_Jtvec_adjointTest_ezr_Eform(self):
                 self.assertTrue(adjointTest('e', 'ezr'))
-            # def test_Jtvec_adjointTest_ezr_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'ezr'))
             def test_Jtvec_adjointTest_exi_Eform(self):
                 self.assertTrue(adjointTest('e', 'exi'))
-            # def test_Jtvec_adjointTest_exi_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'exi'))
             def test_Jtvec_adjointTest_eyi_Eform(self):
                 self.assertTrue(adjointTest('e', 'eyi'))
-            # def test_Jtvec_adjointTest_eyi_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'eyi'))
             def test_Jtvec_adjointTest_ezi_Eform(self):
                 self.assertTrue(adjointTest('e', 'ezi'))
-            # def test_Jtvec_adjointTest_ezi_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'ezi'))
 
             def test_Jtvec_adjointTest_bxr_Eform(self):
                 self.assertTrue(adjointTest('e', 'bxr'))
-            # def test_Jtvec_adjointTest_bxr_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'bxr'))
             def test_Jtvec_adjointTest_byr_Eform(self):
                 self.assertTrue(adjointTest('e', 'byr'))
-            # def test_Jtvec_adjointTest_byr_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'byr'))
             def test_Jtvec_adjointTest_bzr_Eform(self):
                 self.assertTrue(adjointTest('e', 'bzr'))
-            # def test_Jtvec_adjointTest_bzr_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'bzr'))
             def test_Jtvec_adjointTest_bxi_Eform(self):
                 self.assertTrue(adjointTest('e', 'bxi'))
-            # def test_Jtvec_adjointTest_bxi_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'bxi'))
             def test_Jtvec_adjointTest_byi_Eform(self):
                 self.assertTrue(adjointTest('e', 'byi'))
-            # def test_Jtvec_adjointTest_byi_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'byi'))
             def test_Jtvec_adjointTest_bzi_Eform(self):
                 self.assertTrue(adjointTest('e', 'bzi'))
-            # def test_Jtvec_adjointTest_bzi_Bform(self):
-            #     self.assertTrue(adjointTest('b', 'bzi'))
+
+            def test_Jtvec_adjointTest_exr_Bform(self):
+                self.assertTrue(adjointTest('b', 'exr'))
+            def test_Jtvec_adjointTest_eyr_Bform(self):
+                self.assertTrue(adjointTest('b', 'eyr'))
+            def test_Jtvec_adjointTest_ezr_Bform(self):
+                self.assertTrue(adjointTest('b', 'ezr'))
+            def test_Jtvec_adjointTest_exi_Bform(self):
+                self.assertTrue(adjointTest('b', 'exi'))
+            def test_Jtvec_adjointTest_eyi_Bform(self):
+                self.assertTrue(adjointTest('b', 'eyi'))
+            def test_Jtvec_adjointTest_ezi_Bform(self):
+                self.assertTrue(adjointTest('b', 'ezi'))
+            def test_Jtvec_adjointTest_bxr_Bform(self):
+                self.assertTrue(adjointTest('b', 'bxr'))
+            def test_Jtvec_adjointTest_byr_Bform(self):
+                self.assertTrue(adjointTest('b', 'byr'))
+            def test_Jtvec_adjointTest_bzr_Bform(self):
+                self.assertTrue(adjointTest('b', 'bzr'))
+            def test_Jtvec_adjointTest_bxi_Bform(self):
+                self.assertTrue(adjointTest('b', 'bxi'))
+            def test_Jtvec_adjointTest_byi_Bform(self):
+                self.assertTrue(adjointTest('b', 'byi'))
+            def test_Jtvec_adjointTest_bzi_Bform(self):
+                self.assertTrue(adjointTest('b', 'bzi'))
+
 
         if testHJ: 
             def test_Jtvec_adjointTest_jxr_Jform(self):