def __init__(self, data, nlay=2, verbose=False):
"""Parameters: FDEM data class and number of layers."""
super(FDEM2dFOP, self).__init__(verbose)
self.nlay = nlay
self.header = {}
self.pos, self.z, self.topo = None, None, None
self.FOP = data.FOP(nlay)
self.nx = len(data.x)
self.nf = len(data.freq())
npar = 2 * nlay - 1
self.mesh1d = pg.createMesh1D(self.nx, npar)
self.mesh_ = pg.createMesh1D(self.nx, 2 * nlay - 1)
self.setMesh(self.mesh_)
# self.J = NDMatrix(self.nx, self.nf*2, npar)
self.J = pg.RBlockMatrix()
self.FOP1d = []
for i in range(self.nx):
self.FOP1d.append(pg.FDEM1dModelling(
nlay, data.freq(), data.coilSpacing, -data.height))
n = self.J.addMatrix(self.FOP1d[-1].jacobian())
self.J.addMatrixEntry(n, self.nf * 2 * i, npar * i)
self.J.recalcMatrixSize()
print(self.J.rows(), self.J.cols())
def __init__(self, data, nlay=2, verbose=False):
"""Parameters: FDEM data class and number of layers."""
super(FDEM2dFOP, self).__init__(verbose)
self.nlay = nlay
self.header = {}
self.pos, self.z, self.topo = None, None, None
self.FOP = data.FOP(nlay)
self.nx = len(data.x)
self.nf = len(data.freq())
npar = 2 * nlay - 1
self.mesh1d = pg.createMesh1D(self.nx, npar)
self.mesh_ = pg.createMesh1D(self.nx, 2 * nlay - 1)
self.setMesh(self.mesh_)
# self.J = NDMatrix(self.nx, self.nf*2, npar)
self.J = pg.RBlockMatrix()
self.FOP1d = []
for i in range(self.nx):
self.FOP1d.append(
pg.FDEM1dModelling(nlay, data.freq(), data.coilSpacing,
-data.height))
n = self.J.addMatrix(self.FOP1d[-1].jacobian())
self.J.addMatrixEntry(n, self.nf * 2 * i, npar * i)
self.J.recalcMatrixSize()
print(self.J.rows(), self.J.cols())
def __init__(self, fvec, tvec, verbose=False): # save reference in class
"""constructor with frequecy and tau vector"""
self.f_ = fvec
self.nf_ = len(fvec)
self.t_ = tvec
mesh = pg.createMesh1D(len(tvec)) # standard 1d discretization
pg.ModellingBase.__init__(self, mesh, verbose)
def test_createMesh1D(self):
mesh = pg.createMesh1D(10, 1)
self.assertEqual(mesh.cellCount(), 10.0)
mesh = pg.createMesh1D(nCells=10)
self.assertEqual(mesh.cellCount(), 10.0)
mesh = pg.createMesh1D(nCells=5, nProperties=2)
self.assertEqual(mesh.cellCount(), 10.0)
mesh = pg.createMesh1D(5, 2)
self.assertEqual(mesh.cellCount(), 10.0)
mesh = pg.createMesh1D(10)
self.assertEqual(mesh.cellCount(), 10.0)
def test_createMesh1D(self):
mesh = pg.createMesh1D(10, 1)
self.assertEqual(mesh.cellCount(), 10.0)
mesh = pg.createMesh1D(nCells=10)
self.assertEqual(mesh.cellCount(), 10.0)
mesh = pg.createMesh1D(nCells=5, nProperties=2)
self.assertEqual(mesh.cellCount(), 10.0)
mesh = pg.createMesh1D(5, 2)
self.assertEqual(mesh.cellCount(), 10.0)
mesh = pg.createMesh1D(10)
self.assertEqual(mesh.cellCount(), 10.0)
def __init__(self, frequencies, coilspacing, nlay=2, verbose=False):
"""Set up class by frequencies and geometries."""
pg.ModellingBase.__init__(self, verbose)
self.nlay_ = nlay # real layers (actually one more!)
self.FOP_ = pg.FDEM1dModelling(nlay + 1, frequencies, coilspacing, 0.0)
self.mesh_ = pg.createMesh1D(nlay, 2) # thicknesses and resistivities
self.mesh_.cell(0).setMarker(2)
self.setMesh(self.mesh_)
def __init__(self, dvec, *args, **kwargs):
""" not yet working! """
self.nlay = len(dvec) + 1
self.dvec = np.asarray(dvec)
self.zvec = np.hstack((0, np.cumsum(dvec)))
HEMmodelling.__init__(self, self.nlay, *args, **kwargs)
self.mymesh = pg.createMesh1D(self.nlay, nProperties=2)
self.setMesh(self.mymesh) # only for inversion
def __init__(self, dvec, height=1., **kwargs):
"""Init class by specifying frequencies and distances (s. HEMMod)."""
nlay = len(dvec) + 1
self.dvec = np.asarray(dvec)
self.zvec = np.hstack((0, np.cumsum(dvec)))
HEMmodelling.__init__(self, nlay, height, **kwargs)
self.mymesh = pg.createMesh1D(nlay)
self.setMesh(self.mymesh) # only for inversion
def __init__(self, dvec, *args, **kwargs):
""" not yet working! """
self.nlay = len(dvec) + 1
self.dvec = np.asarray(dvec)
self.zvec = np.hstack((0, np.cumsum(dvec)))
HEMmodelling.__init__(self, self.nlay, *args, **kwargs)
self.mymesh = pg.createMesh1D(self.nlay, nProperties=2)
self.setMesh(self.mymesh) # only for inversion
def test_createPartMesh(self):
mesh = pg.createMesh1D(np.linspace(0, 1, 10))
self.assertEqual(mesh.cellCount(), 9)
mesh2 = mesh.createMeshByCellIdx(
pg.find(pg.x(mesh.cellCenters()) < 0.5))
self.assertEqual(mesh2.cellCount(), 4)
self.assertEqual(mesh2.cellCenters()[-1][0] < 0.5, True)
def __init__(self, dvec, height, verbose):
""" not yet working! """
nlay = len(dvec)
self.height = height
self.wem = (2.0 * pi * self.f) ** 2 * self.ep0 * self.mu0
self.iwm = np.complex(0, 1) * 2.0 * pi * self.f * self.mu0
mesh = pg.createMesh1D(nlay)
pg.ModellingBase.__init__(self, mesh)
def test_createPartMesh(self):
mesh = pg.createMesh1D(np.linspace(0, 1, 10))
self.assertEqual(mesh.cellCount(), 9)
mesh2 = mesh.createMeshByCellIdx(
pg.find(pg.x(mesh.cellCenters()) < 0.5))
self.assertEqual(mesh2.cellCount(), 4)
self.assertEqual(mesh2.cellCenters()[-1][0] < 0.5, True)
def __init__(self, fvec, tvec, verbose=False): # save reference in class
"""constructor with frequecy and tau vector"""
self.f_ = fvec
self.nf_ = len(fvec)
self.t_ = tvec
pg.ModellingBase.__init__(self, verbose)
self.mesh = pg.createMesh1D(len(tvec)) # standard 1d discretization
self.setMesh(self.mesh)
def __init__(self, dvec, height=1., **kwargs):
"""Init class by specifying frequencies and distances (s. HEMMod)."""
nlay = len(dvec) + 1
self.dvec = np.asarray(dvec)
self.zvec = np.hstack((0, np.cumsum(dvec)))
HEMmodelling.__init__(self, nlay, height, **kwargs)
self.mymesh = pg.createMesh1D(nlay)
self.setMesh(self.mymesh) # only for inversion
def __init__(self, frequencies, coilspacing, nlay=2, verbose=False):
""" Set up class by frequencies and geometries """
pg.ModellingBase.__init__(self, verbose)
self.nlay_ = nlay # real layers (actually one more!)
self.FOP_ = pg.FDEM1dModelling(nlay + 1, frequencies, coilspacing, 0.0)
self.mesh_ = pg.createMesh1D(nlay, 2) # thicknesses and resistivities
self.mesh_.cell(0).setMarker(2)
self.setMesh(self.mesh_)
def __init__(self, data, nlay=2, verbose=False):
""" constructor with data and (optionally) number of layers """
pg.ModellingBase.__init__(self, verbose)
self.nlay = nlay
self.FOP1d = data.FOP(nlay)
self.nx = len(data.x)
self.nf = len(data.freq())
self.mesh_ = pg.createMesh1D(self.nx, 2 * nlay - 1)
self.setMesh(self.mesh_)
def __init__(self, data, nlay=2, verbose=False):
""" constructor with data and (optionally) number of layers """
pg.ModellingBase.__init__(self, verbose)
self.nlay = nlay
self.FOP1d = data.FOP(nlay)
self.nx = len(data.x)
self.nf = len(data.freq())
self.mesh_ = pg.createMesh1D(self.nx, 2 * nlay - 1)
self.setMesh(self.mesh_)
def __init__(self, data, nlay=2, verbose=False):
"""
"""
pg.ModellingBase.__init__(self, verbose)
self.nlay_ = nlay
self.FOP_ = data.FOP(nlay)
self.nx_ = len(data.x)
self.nf = len(data.freq())
self.mesh_ = pg.createMesh1D(self.nx_, 2*nlay-1)
self.setMesh(self.mesh_)
def __init__(self, fvec, tvec=None, zero = False, verbose = False):
if tvec == None:
tvec = N.logspace(-4, 0, 5)
mesh = pg.createMesh1D(len(tvec))
if zero:
mesh.cell(0).setMarker(-1)
mesh.cell(len(tvec)-1).setMarker(1)
pg.ModellingBase.__init__(self, mesh, verbose)
self.f_ = pg.asvector(fvec)
self.t_ = tvec
self.zero_ = zero
def createFOP(self):
"""Creates the forward operator instance."""
if self.type == 'block':
self.FOP = pg.DC1dModelling(self.Z, self.ab2, self.mn2)
mesh1D = pg.createMesh1DBlock(self.Z)
if self.type == 'smooth':
self.FOP = pg.DC1dRhoModelling(self.Z, self.ab2, self.mn2)
mesh1D = pg.createMesh1D(nCells=len(self.Z) + 1)
self.FOP.setMesh(mesh1D)
self.applyModelTrans()
def createFOP(self):
"""Creates the forward operator instance."""
if self.type == 'block':
self.FOP = pg.DC1dModelling(self.Z, self.ab2, self.mn2)
mesh1D = pg.createMesh1DBlock(self.Z)
if self.type == 'smooth':
self.FOP = pg.DC1dRhoModelling(self.Z, self.ab2, self.mn2)
mesh1D = pg.createMesh1D(nCells=len(self.Z) + 1)
self.FOP.setMesh(mesh1D)
self.applyModelTrans()
def ReadAndRemoveEM(filename, readsecond=False, doplot=False,
dellast=True, ePhi=0.5, ePerc=1., lam=2000.):
""" Read res1file and remove EM effects using a double-Cole-Cole model
fr,rhoa,phi,dphi = ReadAndRemoveEM(filename, readsecond/doplot bools)"""
fr, rhoa, phi, drhoa, dphi = read1resfile(filename, readsecond,
dellast=dellast)
# forward problem
mesh = pg.createMesh1D(1, 6) # 6 independent parameters
f = DoubleColeColeModelling(mesh, pg.asvector(fr) , phi[2]/abs(phi[2]))
f.regionManager().loadMap("region.control")
model = f.createStartVector()
# inversion
inv = pg.RInversion(phi, f, True, False)
inv.setAbsoluteError(phi * ePerc * 0.01 + ePhi / 1000.)
inv.setRobustData(True)
# inv.setCWeight(pg.RVector(6, 1.0)) # wozu war das denn gut?
inv.setMarquardtScheme(0.8)
inv.setLambda(lam)
inv.setModel(model)
erg = inv.run()
inv.echoStatus()
chi2 = inv.chi2()
mod0 = pg.RVector(erg)
mod0[ 0 ] = 0.0 # set IP term to zero to obtain pure EM term
emphi = f(mod0)
resid = (phi - emphi) * 1000.
if doplot:
s = "IP: m= " + str(rndig(erg[0])) + " t=" + str(rndig(erg[1])) + \
" c =" + str(rndig(erg[2]))
s = s + " EM: m= " + str(rndig(erg[3])) + " t=" + str(rndig(erg[4])) +\
" c =" + str(rndig(erg[5]))
fig = P.figure(1)
fig.clf()
ax = P.subplot(111)
P.errorbar(fr, phi*1000., yerr=dphi*1000., fmt='x-', label='measured')
ax.set_xscale('log')
P.semilogx(fr, f(mod0) * 1000., label='EM term (CC)')
P.errorbar(fr, resid, yerr=dphi*1000., label='IP term')
ax.set_yscale('log')
P.xlim((min(fr), max(fr)))
P.ylim((0.1, max(phi) * 1000.))
P.xlabel('f in Hz')
P.ylabel(r'-$\phi$ in mrad')
P.grid(True)
P.title(s)
P.legend(loc=2)#('measured','2-cole-cole','residual'))
fig.show()
return N.array(fr), N.array(rhoa), N.array(resid), N.array(phi)*1e3, dphi, chi2, N.array(emphi)*1e3
def __init__(self, fvec, tvec=None, zero=False, verbose=False):
if tvec is None:
tvec = N.logspace(-4, 0, 5)
mesh = pg.createMesh1D(len(tvec))
if zero:
mesh.cell(0).setMarker(-1)
mesh.cell(len(tvec) - 1).setMarker(1)
pg.ModellingBase.__init__(self, mesh, verbose)
self.f_ = pg.asvector(fvec)
self.t_ = tvec
self.zero_ = zero
def __init__(self, fvec, tvec, verbose=False): # save reference in class
"""constructor with frequecy and tau vector"""
self.f = fvec
self.nf = len(fvec)
self.t = tvec
self.nt = len(tvec)
mesh = pg.createMesh1D(len(tvec)) # standard 1d discretization
pg.ModellingBase.__init__(self, mesh, verbose)
T, W = np.meshgrid(tvec, fvec * 2. * pi)
WT = W * T
self.A = WT**2 / (WT**2 + 1)
self.B = WT / (WT**2 + 1)
self.J = pg.RMatrix()
self.J.resize(len(fvec) * 2, len(tvec))
for i in range(self.nf):
wt = fvec[i] * 2.0 * pi * tvec
wt2 = wt**2
self.J[i] = wt2 / (wt2 + 1.0)
self.J[i + self.nf] = wt / (wt2 + 1.0)
self.setJacobian(self.J)
def __init__(self, fvec, tvec, verbose=False): # save reference in class
"""constructor with frequecy and tau vector"""
self.f = fvec
self.nf = len(fvec)
self.t = tvec
self.nt = len(tvec)
mesh = pg.createMesh1D(len(tvec)) # standard 1d discretization
pg.ModellingBase.__init__(self, mesh, verbose)
T, W = np.meshgrid(tvec, fvec * 2. * pi)
WT = W*T
self.A = WT**2 / (WT**2 + 1)
self.B = WT / (WT**2+1)
self.J = pg.RMatrix()
self.J.resize(len(fvec)*2, len(tvec))
for i in range(self.nf):
wt = fvec[i] * 2.0 * pi * tvec
wt2 = wt**2
self.J[i] = wt2 / (wt2 + 1.0)
self.J[i+self.nf] = wt / (wt2 + 1.0)
self.setJacobian(self.J)
def __init__(self, f, verbose=False): # initialize class
"""Setup class by specifying the frequency."""
pg.ModellingBase.__init__(self, verbose) # call default constructor
self.f_ = f # save frequencies
self.setMesh(pg.createMesh1D(1, 6)) # 4 single parameters
def __init__(self, f, verbose=False): # initialize class
pg.ModellingBase.__init__(self, verbose) # call default constructor
self.f_ = f # save frequencies
self.setMesh(pg.createMesh1D(1, 4)) # 4 single parameters
def __init__(self, xvec, verbose=False):
pg.ModellingBase.__init__(self, verbose)
self.x = xvec
self.setMesh(pg.createMesh1D(1, 2))
def __init__(self, xvec, verbose=False):
pg.ModellingBase.__init__(self, verbose)
self.x = xvec
self.setMesh(pg.createMesh1D(1, 2))
def __init__(self, f, verbose=False): # initialize class
"""Setup class by specifying the frequency."""
pg.ModellingBase.__init__(self, verbose) # call default constructor
self.f_ = f # save frequencies
self.setMesh(pg.createMesh1D(1, 6)) # 4 single parameters
def __init__(self, f, verbose=False):
"""Setup class by specifying the frequency."""
pg.ModellingBase.__init__(self, verbose)
self.f_ = f
self.setMesh(pg.createMesh1D(1, 3))
def __init__(self, f, verbose=False):
"""Setup class by specifying the frequency."""
pg.ModellingBase.__init__(self, verbose)
self.f_ = f
self.setMesh(pg.createMesh1D(1, 3))
def ReadAndRemoveEM(filename, readsecond=False, doplot=False,
dellast=True, ePhi=0.5, ePerc=1., lam=2000.):
"""
Read res1file and remove EM effects using a double-Cole-Cole model
fr,rhoa,phi,dphi = ReadAndRemoveEM(filename, readsecond/doplot bools)
"""
fr, rhoa, phi, drhoa, dphi = read1resfile(filename,
readsecond,
dellast=dellast)
# forward problem
mesh = pg.createMesh1D(1, 6) # 6 independent parameters
f = DoubleColeColeModelling(mesh, pg.asvector(fr), phi[2] / abs(phi[2]))
f.regionManager().loadMap("region.control")
model = f.createStartVector()
# inversion
inv = pg.RInversion(phi, f, True, False)
inv.setAbsoluteError(phi * ePerc * 0.01 + ePhi / 1000.)
inv.setRobustData(True)
# inv.setCWeight(pg.RVector(6, 1.0)) # wozu war das denn gut?
inv.setMarquardtScheme(0.8)
inv.setLambda(lam)
inv.setModel(model)
erg = inv.run()
inv.echoStatus()
chi2 = inv.chi2()
mod0 = pg.RVector(erg)
mod0[0] = 0.0 # set IP term to zero to obtain pure EM term
emphi = f.response(mod0)
resid = (phi - emphi) * 1000.
if doplot:
s = "IP: m= " + str(rndig(erg[0])) + " t=" + str(rndig(erg[1])) + \
" c =" + str(rndig(erg[2]))
s += " EM: m= " + str(rndig(erg[3])) + " t=" + str(rndig(erg[4])) + \
" c =" + str(rndig(erg[5]))
fig = P.figure(1)
fig.clf()
ax = P.subplot(111)
P.errorbar(
fr,
phi *
1000.,
yerr=dphi *
1000.,
fmt='x-',
label='measured')
ax.set_xscale('log')
P.semilogx(fr, emphi * 1000., label='EM term (CC)')
P.errorbar(fr, resid, yerr=dphi * 1000., label='IP term')
ax.set_yscale('log')
P.xlim((min(fr), max(fr)))
P.ylim((0.1, max(phi) * 1000.))
P.xlabel('f in Hz')
P.ylabel(r'-$\phi$ in mrad')
P.grid(True)
P.title(s)
P.legend(loc=2) # ('measured','2-cole-cole','residual'))
fig.show()
return N.array(fr), N.array(rhoa), N.array(resid), N.array(
phi) * 1e3, dphi, chi2, N.array(emphi) * 1e3
def __init__(self, f, verbose=False): # initialize class
pg.ModellingBase.__init__(self, verbose) # call default constructor
self.f_ = f # save frequencies
self.setMesh(pg.createMesh1D(1, 4)) # 4 single parameters
