diff --git a/simpegEM/Base.py b/simpegEM/Base.py index 7f6c9766..38172087 100644 --- a/simpegEM/Base.py +++ b/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 diff --git a/simpegEM/FDEM/FDEM.py b/simpegEM/FDEM/FDEM.py index 75e880ac..58d7fcba 100644 --- a/simpegEM/FDEM/FDEM.py +++ b/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 diff --git a/simpegEM/FDEM/FieldsFDEM.py b/simpegEM/FDEM/FieldsFDEM.py index c98edba8..bf1175e8 100644 --- a/simpegEM/FDEM/FieldsFDEM.py +++ b/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): diff --git a/simpegEM/FDEM/SurveyFDEM.py b/simpegEM/FDEM/SurveyFDEM.py index 44dbfa58..47749ef0 100644 --- a/simpegEM/FDEM/SurveyFDEM.py +++ b/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) diff --git a/simpegEM/Tests/test_FDEM.py b/simpegEM/Tests/test_FDEM.py index b9121b6f..bc4e9807 100644 --- a/simpegEM/Tests/test_FDEM.py +++ b/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):