diff --git a/SimPEG/EM/FDEM/FDEM.py b/SimPEG/EM/FDEM/FDEM.py
index 37c79236..349b3bdb 100644
--- a/SimPEG/EM/FDEM/FDEM.py
+++ b/SimPEG/EM/FDEM/FDEM.py
@@ -67,37 +67,28 @@ class BaseFDEMProblem(BaseEMProblem):
         Jv = self.dataPair(self.survey)
 
         for freq in self.survey.freqs:
-            dA_du = self.getA(freq) #
-            dA_duI = self.Solver(dA_du, **self.solverOpts)
+            A = self.getA(freq) #
+            Ainv = self.Solver(A, **self.solverOpts)
 
             for src in self.survey.getSrcByFreq(freq):
                 ftype = self._fieldType + 'Solution'
                 u_src = f[src, ftype]
                 dA_dm = self.getADeriv_m(freq, u_src, v)
                 dRHS_dm = self.getRHSDeriv_m(freq, src, v) 
-                # if dRHS_dm is None:
-                    # du_dm = dA_duI * ( - dA_dm )
-                # else:
-                du_dm = dA_duI * ( - dA_dm + dRHS_dm )
+                du_dm = Ainv * ( - dA_dm + dRHS_dm )
                 
-
                 for rx in src.rxList:
-                    # 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
+                    df_dudu_dm = df_duFun(src, du_dm, adjoint=False)
 
                     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
+
+                    Df_Dm = np.array(df_dudu_dm + df_dm,dtype=complex)
 
                     P = lambda v: rx.projectFieldsDeriv(src, self.mesh, f, v) # wrt u, also have wrt m
 
-                    Jv[src, rx] = P(du_dm)
+                    Jv[src, rx] = P(Df_Dm)
 
         return Utils.mkvc(Jv)
 
@@ -130,23 +121,16 @@ class BaseFDEMProblem(BaseEMProblem):
 
                     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:
-                    #     dA_duIT = ATinv * PTv
+                    
+                    ATinvdf_duT = ATinv * df_duT
 
-                    dA_dmT = self.getADeriv_m(freq, u_src, dA_duIT, adjoint=True)
-
-                    dRHS_dmT = self.getRHSDeriv_m(freq,src, dA_duIT, adjoint=True)
-
-                    # if dRHS_dmT is None:
-                    # du_dmT = - dA_dmT
-                    # else:
+                    dA_dmT = self.getADeriv_m(freq, u_src, ATinvdf_duT, adjoint=True)
+                    dRHS_dmT = self.getRHSDeriv_m(freq,src, ATinvdf_duT, adjoint=True)
                     du_dmT = -dA_dmT + dRHS_dmT
 
                     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
 
                     real_or_imag = rx.projComp
@@ -379,43 +363,27 @@ class ProblemFDEM_b(BaseFDEMProblem):
         C = self.mesh.edgeCurl
         S_m, S_e = src.eval(self)
         MfMui = self.MfMui
-        # Me = self.Me
 
         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:
+        print RHSderiv, SrcDeriv
         RHSderiv += SrcDeriv
-        # elif SrcDeriv is not None:
-        #     RHSderiv = SrcDeriv
 
-        # if RHSderiv is not None:
         if self._makeASymmetric is True and not adjoint:
             return MfMui.T * RHSderiv
 
@@ -635,9 +603,6 @@ class ProblemFDEM_h(BaseFDEMProblem):
         C = self.mesh.edgeCurl
         MfRho  = self.MfRho
 
-        # RHSDeriv = Zero()
-
-        # if S_e is not None:
         MfRhoDeriv = self.MfRhoDeriv(S_e)
         if not adjoint:
             RHSDeriv = C.T * (MfRhoDeriv * v)