def ePrimary(self, prob):
"""
Primary electric field
:param BaseFDEMProblem prob: FDEM Problem
:rtype: numpy.ndarray
:return: primary electric field
"""
if self._ePrimary is None:
return Zero()
return self._ePrimary
def s_eDeriv(self, prob, v, adjoint=False):
"""
Derivative of electric source term with respect to the inversion model
:param BaseFDEMProblem prob: FDEM Problem
:param numpy.ndarray v: vector to take product with
:param bool adjoint: adjoint?
:rtype: numpy.ndarray
:return: product of electric source term derivative with a vector
"""
return Zero()
def bPrimary(self, prob):
"""
Primary magnetic flux density
:param BaseFDEMProblem prob: FDEM Problem
:rtype: numpy.ndarray
:return: primary magnetic flux density
"""
if self._bPrimary is None:
return Zero()
return self._bPrimary
def jPrimary(self, prob):
"""
Primary current density
:param BaseFDEMProblem prob: FDEM Problem
:rtype: numpy.ndarray
:return: primary current density
"""
if self._jPrimary is None:
return Zero()
return self._jPrimary
def ePrimaryDeriv(self, prob, v, adjoint=False):
"""
Derivative of the primary electric field
:param BaseFDEMProblem prob: FDEM Problem
:param numpy.ndarray v: vector
:param bool adjoint: adjoint?
:rtype: numpy.ndarray
:return: primary magnetic flux density
"""
return Zero()
def _bDeriv_m(self, src, v, adjoint=False):
"""
Derivative of the magnetic flux density with respect to the inversion model.
:param SimPEG.EM.FDEM.Src src: source
:param numpy.ndarray v: vector to take product with
:param bool adjoint: adjoint?
:rtype: numpy.ndarray
:return: product of the magnetic flux density derivative with respect to the inversion model with a vector
"""
# Neither bPrimary nor bSeconary have model dependency => return Zero
return Zero()
def _phiInitialDeriv(self, prob, v, adjoint=False):
if self.waveform.hasInitialFields:
phi = self.phiInitial(prob)
if adjoint is True:
return -1. * prob.getAdcDeriv(phi, prob.Adcinv * v, adjoint=True) # A is symmetric
Adc_deriv = prob.getAdcDeriv(phi, v)
return -1. * ( prob.Adcinv * Adc_deriv )
else:
return Zero()
def _eDeriv_m(self, src, v, adjoint=False):
"""
Partial derivative of the total electric field with respect to the inversion model. Here, we assume that the primary does not depend on the model. Note that this also includes derivative contributions from the sources.
:param SimPEG.EM.FDEM.Src src: source
:param numpy.ndarray v: vector to take product with
:param bool adjoint: adjoint?
:rtype: SimPEG.Utils.Zero
:return: product of the electric field derivative with respect to the inversion model with a vector
"""
# assuming primary does not depend on the model
return Zero()
def s_e(self, prob, time):
C = prob.mesh.edgeCurl
b = self._bSrc(prob)
if prob._formulation == 'EB':
MfMui = prob.MfMui
if self.waveform.hasInitialFields is True and time < prob.timeSteps[
1]:
# if time > 0.0:
# return Zero()
if prob._fieldType == 'b':
return Zero()
elif prob._fieldType == 'e':
# Compute s_e from vector potential
return C.T * (MfMui * b)
else:
# b = self._bfromVectorPotential(prob)
return C.T * (MfMui * b) * self.waveform.eval(time)
# return Zero()
elif prob._formulation == 'HJ':
h = 1. / self.mu * b
if self.waveform.hasInitialFields is True and time < prob.timeSteps[
1]:
# if time > 0.0:
# return Zero()
if prob._fieldType == 'h':
return Zero()
elif prob._fieldType == 'j':
# Compute s_e from vector potential
return C * h
else:
# b = self._bfromVectorPotential(prob)
return C * h * self.waveform.eval(time)
def eInitialDeriv(self, prob, v=None, adjoint=False, f=None):
if self.waveform.hasInitialFields:
edc = f[self, 'e', 0]
Grad = prob.mesh.nodalGrad
if adjoint is False:
AdcDeriv_v = prob.getAdcDeriv(edc, v, adjoint=adjoint)
edcDeriv = Grad * (prob.Adcinv * AdcDeriv_v)
return edcDeriv
elif adjoint is True:
vec = prob.Adcinv * (Grad.T * v)
edcDerivT = prob.getAdcDeriv(edc, vec, adjoint=adjoint)
return edcDerivT
else:
return Zero()
def _e_pyDeriv_m(self, src, v, adjoint=False):
"""
Derivative of e_py wrt m
:param SimPEG.NSEM.src src: The source of the problem
:param numpy.ndarray v: vector to take product with Size (nE,) when adjoint=True, (nU,) when adjoint=False
:param bool adjoint: adjoint?
:rtype: numpy.ndarray
:return: The calculated derivative, size (nU,) when adjoint=True (nE,) when adjoint=False
"""
# e_py does not depend on the model
return Zero()
def bInitial(self, prob):
if self.waveform.hasInitialFields is False:
return Zero()
if np.all(prob.mu == self.mu):
return self._bSrc(prob)
else:
if prob._formulation == 'EB':
hs = prob.mesh.faceDiv.T * self._phiSrc(prob)
ht = self._hp + hs
return prob.MfMuiI * ht
else:
raise NotImplementedError
def jInitialDeriv(self, prob, v, adjoint=False):
if prob._fieldType not in ['j', 'h']:
raise NotImplementedError
if self.waveform.hasInitialFields is False:
return Zero()
phi = self.phiInitial(prob)
Div = Utils.sdiag(prob.mesh.vol) * prob.mesh.faceDiv
if adjoint is True:
return - (
prob.MfRhoIDeriv(Div.T * phi, v=v, adjoint=True) +
self._phiInitialDeriv(prob, Div * (prob.MfRhoI.T * v), adjoint=True)
)
phiDeriv = self._phiInitialDeriv(prob, v)
return - (prob.MfRhoIDeriv(Div.T * phi, v=v) + prob.MfRhoI * (Div.T * phiDeriv))
def s_e(self, prob, time):
b = self._bfromVectorPotential(prob)
MfMui = prob.MfMui
C = prob.mesh.edgeCurl
# print 'time ', time
if self.waveform.hasInitialFields is True and time < prob.timeSteps[1]:
# if time > 0.0:
# return Zero()
if prob._fieldType == 'b':
return Zero()
elif prob._fieldType == 'e':
# Compute s_e from vector potential
return C.T * (MfMui * b)
else:
# b = self._bfromVectorPotential(prob)
return C.T * (MfMui * b) * self.waveform.eval(time)
def S_e(self, prob):
"""
The electric source term
:param Problem prob: FDEM problem
:rtype: numpy.ndarray
:return: primary magnetic field
"""
if all(np.r_[self.mu] == np.r_[prob.curModel.mu]):
return Zero()
else:
formulation = prob._formulation
if formulation is 'EB':
mui_s = prob.curModel.mui - 1. / self.mu
MMui_s = prob.mesh.getFaceInnerProduct(mui_s)
C = prob.mesh.edgeCurl
elif formulation is 'HJ':
mu_s = prob.curModel.mu - self.mu
MMui_s = prob.mesh.getEdgeInnerProduct(mu_s, invMat=True)
C = prob.mesh.edgeCurl.T
return -C.T * (MMui_s * self.bPrimary(prob))
def _jDeriv_m(self, tInd, src, v, adjoint=False):
return Zero() # assumes the source doesn't depend on the model
def s_m(self, prob, time):
if self.waveform.hasInitialFields is False:
# raise NotImplementedError
return Zero()
return Zero()
def eInitial(self, prob):
# when solving for e, it is easier to work with an initial source than
# initial fields
# if self.waveform.hasInitialFields is False or prob._fieldType is 'e':
return Zero()
def bInitial(self, prob):
if self.waveform.hasInitialFields is False:
return Zero()
return self._bfromVectorPotential(prob)
def s_eDeriv(self, prob, time, v=None, adjoint=False):
return Zero()
def s_e(self, prob, time):
return Zero()
def _b_pyDeriv_m(self, src, v, adjoint=False):
""" Derivative of b_py wrt m """
# b_py does not depend on the model
return Zero()
def bInitial(self, prob):
if self.waveform.eval(0) == 1.:
raise Exception("Not implemetned for computing b!")
else:
return Zero()
def hInitial(self, prob):
if self.waveform.hasInitialFields is False:
return Zero()
return 1./self.mu * self._bSrc(prob)
def eInitial(self, prob):
return Zero()
def test_both(self):
z = Zero()
o = Identity()
assert o*z == 0
assert o*z + o == 1
assert o-z == 1
def eInitialDeriv(self, prob, v=None, adjoint=False):
return Zero()
def _jDeriv_m(self, tInd, src, v, adjoint=False):
return Zero()
def test_mat_zero(self):
z = Zero()
S = sdiag(np.r_[2,3])
assert S*z == 0
def _b_pxDeriv_m(self, src, v, adjoint=False):
''' Derivative of b_px wrt m '''
# b_px does not depend on the model
return Zero()
