mirror of
https://github.com/wassname/simpeg.git
synced 2026-06-27 19:48:52 +08:00
seogi_macbook
297 lines
8.4 KiB
Python
297 lines
8.4 KiB
Python
from SimPEG import Problem, Utils
|
|
from SimPEG.EM.Base import BaseEMProblem
|
|
from SurveyDC import Survey
|
|
from FieldsDC import Fields, Fields_CC, Fields_N
|
|
from SimPEG.Utils import sdiag
|
|
import numpy as np
|
|
from SimPEG.Utils import Zero
|
|
from BoundaryUtils import getxBCyBC_CC
|
|
|
|
class BaseDCProblem(BaseEMProblem):
|
|
|
|
surveyPair = Survey
|
|
fieldsPair = Fields
|
|
Ainv = None
|
|
|
|
def fields(self, m):
|
|
self.curModel = m
|
|
|
|
if not self.Ainv == None:
|
|
self.Ainv.clean()
|
|
|
|
f = self.fieldsPair(self.mesh, self.survey)
|
|
A = self.getA()
|
|
self.Ainv = self.Solver(A, **self.solverOpts)
|
|
RHS = self.getRHS()
|
|
u = self.Ainv * RHS
|
|
Srcs = self.survey.srcList
|
|
f[Srcs, self._solutionType] = u
|
|
return f
|
|
|
|
def Jvec(self, m, v, f=None):
|
|
|
|
if f is None:
|
|
f = self.fields(m)
|
|
|
|
self.curModel = m
|
|
|
|
Jv = self.dataPair(self.survey) #same size as the data
|
|
|
|
A = self.getA()
|
|
|
|
for src in self.survey.srcList:
|
|
u_src = f[src, self._solutionType] # solution vector
|
|
dA_dm_v = self.getADeriv(u_src, v)
|
|
dRHS_dm_v = self.getRHSDeriv(src, v)
|
|
du_dm_v = self.Ainv * ( - dA_dm_v + dRHS_dm_v )
|
|
|
|
for rx in src.rxList:
|
|
df_dmFun = getattr(f, '_%sDeriv'%rx.projField, None)
|
|
df_dm_v = df_dmFun(src, du_dm_v, v, adjoint=False)
|
|
Jv[src, rx] = rx.evalDeriv(src, self.mesh, f, df_dm_v)
|
|
return Utils.mkvc(Jv)
|
|
|
|
def Jtvec(self, m, v, f=None):
|
|
if f is None:
|
|
f = self.fields(m)
|
|
|
|
self.curModel = m
|
|
|
|
# Ensure v is a data object.
|
|
if not isinstance(v, self.dataPair):
|
|
v = self.dataPair(self.survey, v)
|
|
|
|
Jtv = np.zeros(m.size)
|
|
AT = self.getA()
|
|
|
|
|
|
for src in self.survey.srcList:
|
|
u_src = f[src, self._solutionType]
|
|
for rx in src.rxList:
|
|
PTv = rx.evalDeriv(src, self.mesh, f, v[src, rx], adjoint=True) # wrt f, need possibility wrt m
|
|
df_duTFun = getattr(f, '_%sDeriv'%rx.projField, None)
|
|
df_duT, df_dmT = df_duTFun(src, None, PTv, adjoint=True)
|
|
|
|
ATinvdf_duT = self.Ainv * df_duT
|
|
|
|
dA_dmT = self.getADeriv(u_src, ATinvdf_duT, adjoint=True)
|
|
dRHS_dmT = self.getRHSDeriv(src, ATinvdf_duT, adjoint=True)
|
|
du_dmT = -dA_dmT + dRHS_dmT
|
|
Jtv += (df_dmT + du_dmT).astype(float)
|
|
|
|
return Utils.mkvc(Jtv)
|
|
|
|
def getSourceTerm(self):
|
|
"""
|
|
takes concept of source and turns it into a matrix
|
|
"""
|
|
"""
|
|
Evaluates the sources, and puts them in matrix form
|
|
|
|
:rtype: (numpy.ndarray, numpy.ndarray)
|
|
:return: q (nC or nN, nSrc)
|
|
"""
|
|
|
|
Srcs = self.survey.srcList
|
|
|
|
if self._formulation is 'EB':
|
|
n = self.mesh.nN
|
|
# return NotImplementedError
|
|
|
|
elif self._formulation is 'HJ':
|
|
n = self.mesh.nC
|
|
|
|
q = np.zeros((n, len(Srcs)))
|
|
|
|
for i, src in enumerate(Srcs):
|
|
q[:,i] = src.eval(self)
|
|
return q
|
|
|
|
class Problem3D_CC(BaseDCProblem):
|
|
|
|
_solutionType = 'phiSolution'
|
|
_formulation = 'HJ' # CC potentials means J is on faces
|
|
fieldsPair = Fields_CC
|
|
|
|
def __init__(self, mesh, **kwargs):
|
|
BaseDCProblem.__init__(self, mesh, **kwargs)
|
|
self.setBC()
|
|
|
|
def getA(self):
|
|
"""
|
|
|
|
Make the A matrix for the cell centered DC resistivity problem
|
|
|
|
A = D MfRhoI G
|
|
|
|
"""
|
|
|
|
D = self.Div
|
|
G = self.Grad
|
|
MfRhoI = self.MfRhoI
|
|
A = D * MfRhoI * G
|
|
|
|
# I think we should deprecate this for DC problem.
|
|
# if self._makeASymmetric is True:
|
|
# return V.T * A
|
|
return A
|
|
|
|
def getADeriv(self, u, v, adjoint= False):
|
|
|
|
D = self.Div
|
|
G = self.Grad
|
|
MfRhoIDeriv = self.MfRhoIDeriv
|
|
|
|
if adjoint:
|
|
return(MfRhoIDeriv( G * u ).T) * ( D.T * v)
|
|
|
|
return D * (MfRhoIDeriv( G * u ) * v)
|
|
|
|
def getRHS(self):
|
|
"""
|
|
RHS for the DC problem
|
|
|
|
q
|
|
"""
|
|
|
|
RHS = self.getSourceTerm()
|
|
|
|
return RHS
|
|
|
|
def getRHSDeriv(self, src, v, adjoint=False):
|
|
"""
|
|
Derivative of the right hand side with respect to the model
|
|
"""
|
|
# TODO: add qDeriv for RHS depending on m
|
|
# qDeriv = src.evalDeriv(self, adjoint=adjoint)
|
|
# return qDeriv
|
|
return Zero()
|
|
|
|
def setBC(self):
|
|
if self.mesh.dim==3:
|
|
fxm,fxp,fym,fyp,fzm,fzp = self.mesh.faceBoundaryInd
|
|
gBFxm = self.mesh.gridFx[fxm,:]
|
|
gBFxp = self.mesh.gridFx[fxp,:]
|
|
gBFym = self.mesh.gridFy[fym,:]
|
|
gBFyp = self.mesh.gridFy[fyp,:]
|
|
gBFzm = self.mesh.gridFz[fzm,:]
|
|
gBFzp = self.mesh.gridFz[fzp,:]
|
|
|
|
# Setup Mixed B.C (alpha, beta, gamma)
|
|
temp_xm, temp_xp = np.ones_like(gBFxm[:,0]), np.ones_like(gBFxp[:,0])
|
|
temp_ym, temp_yp = np.ones_like(gBFym[:,1]), np.ones_like(gBFyp[:,1])
|
|
temp_zm, temp_zp = np.ones_like(gBFzm[:,2]), np.ones_like(gBFzp[:,2])
|
|
|
|
alpha_xm, alpha_xp = temp_xm*0., temp_xp*0.
|
|
alpha_ym, alpha_yp = temp_ym*0., temp_yp*0.
|
|
alpha_zm, alpha_zp = temp_zm*0., temp_zp*0.
|
|
|
|
beta_xm, beta_xp = temp_xm, temp_xp
|
|
beta_ym, beta_yp = temp_ym, temp_yp
|
|
beta_zm, beta_zp = temp_zm, temp_zp
|
|
|
|
gamma_xm, gamma_xp = temp_xm*0., temp_xp*0.
|
|
gamma_ym, gamma_yp = temp_ym*0., temp_yp*0.
|
|
gamma_zm, gamma_zp = temp_zm*0., temp_zp*0.
|
|
|
|
alpha = [alpha_xm, alpha_xp, alpha_ym, alpha_yp, alpha_zm, alpha_zp]
|
|
beta = [beta_xm, beta_xp, beta_ym, beta_yp, beta_zm, beta_zp]
|
|
gamma = [gamma_xm, gamma_xp, gamma_ym, gamma_yp, gamma_zm, gamma_zp]
|
|
|
|
elif self.mesh.dim==2:
|
|
|
|
fxm,fxp,fym,fyp = self.mesh.faceBoundaryInd
|
|
gBFxm = self.mesh.gridFx[fxm,:]
|
|
gBFxp = self.mesh.gridFx[fxp,:]
|
|
gBFym = self.mesh.gridFy[fym,:]
|
|
gBFyp = self.mesh.gridFy[fyp,:]
|
|
|
|
# Setup Mixed B.C (alpha, beta, gamma)
|
|
temp_xm, temp_xp = np.ones_like(gBFxm[:,0]), np.ones_like(gBFxp[:,0])
|
|
temp_ym, temp_yp = np.ones_like(gBFym[:,1]), np.ones_like(gBFyp[:,1])
|
|
|
|
alpha_xm, alpha_xp = temp_xm*0., temp_xp*0.
|
|
alpha_ym, alpha_yp = temp_ym*0., temp_yp*0.
|
|
|
|
beta_xm, beta_xp = temp_xm, temp_xp
|
|
beta_ym, beta_yp = temp_ym, temp_yp
|
|
|
|
gamma_xm, gamma_xp = temp_xm*0., temp_xp*0.
|
|
gamma_ym, gamma_yp = temp_ym*0., temp_yp*0.
|
|
|
|
alpha = [alpha_xm, alpha_xp, alpha_ym, alpha_yp]
|
|
beta = [beta_xm, beta_xp, beta_ym, beta_yp]
|
|
gamma = [gamma_xm, gamma_xp, gamma_ym, gamma_yp]
|
|
|
|
x_BC, y_BC = getxBCyBC_CC(self.mesh, alpha, beta, gamma)
|
|
V = self.Vol
|
|
self.Div = V * self.mesh.faceDiv
|
|
P_BC, B = self.mesh.getBCProjWF_simple()
|
|
M = B*self.mesh.aveCC2F
|
|
self.Grad = self.Div.T - P_BC*Utils.sdiag(y_BC)*M
|
|
|
|
|
|
class Problem3D_N(BaseDCProblem):
|
|
|
|
_solutionType = 'phiSolution'
|
|
_formulation = 'EB' # N potentials means B is on faces
|
|
fieldsPair = Fields_N
|
|
|
|
def __init__(self, mesh, **kwargs):
|
|
BaseDCProblem.__init__(self, mesh, **kwargs)
|
|
|
|
def getA(self):
|
|
"""
|
|
|
|
Make the A matrix for the cell centered DC resistivity problem
|
|
|
|
A = G.T MeSigma G
|
|
|
|
"""
|
|
|
|
MeSigma = self.MeSigma
|
|
Grad = self.mesh.nodalGrad
|
|
A = Grad.T * MeSigma * Grad
|
|
|
|
# Handling Null space of A
|
|
A[0,0] = A[0,0] + 1.
|
|
|
|
return A
|
|
|
|
def getADeriv(self, u, v, adjoint=False):
|
|
"""
|
|
|
|
Product of the derivative of our system matrix with respect to the model and a vector
|
|
|
|
"""
|
|
MeSigma = self.MeSigma
|
|
Grad = self.mesh.nodalGrad
|
|
if not adjoint:
|
|
return Grad.T*(self.MeSigmaDeriv(Grad*u)*v)
|
|
elif adjoint:
|
|
return self.MeSigmaDeriv(Grad*u).T * (Grad*v)
|
|
|
|
|
|
def getRHS(self):
|
|
"""
|
|
RHS for the DC problem
|
|
|
|
q
|
|
"""
|
|
|
|
RHS = self.getSourceTerm()
|
|
return RHS
|
|
|
|
def getRHSDeriv(self, src, v, adjoint=False):
|
|
"""
|
|
Derivative of the right hand side with respect to the model
|
|
"""
|
|
# TODO: add qDeriv for RHS depending on m
|
|
# qDeriv = src.evalDeriv(self, adjoint=adjoint)
|
|
# return qDeriv
|
|
return Zero()
|
|
|
|
|
|
|
|
|