def test_NumpyToRVector(self):
'''
custom_rvalue.cpp
'''
x = np.arange(0, 1., 0.2)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(0, 1., 0.2, dtype=np.float64)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
def test_NumpyToIndexArray(self):
'''
custom_rvalue.cpp
'''
x = np.arange(0, 1., 0.2)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(0, 1., 0.2, dtype=np.float64)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
def test_ListToIndexArray(self):
""" implemented in custom_rvalue.cpp"""
idx = [0, 1, 1, 0]
I = pg.IndexArray(idx)
self.assertEqual(pg.sum(I), sum(idx))
bn = (np.array(idx) > 0) # numpy bool
idx = np.nonzero(bn)[0] # numpy int64
# numyp int64 -> IndexArray
I = pg.IndexArray(idx)
self.assertEqual(I.size(), 2)
self.assertEqual(pg.sum(I), sum(idx))
def test_ListToIndexArray(self):
""" implemented in custom_rvalue.cpp"""
idx = [0, 1, 1, 0]
I = pg.IndexArray(idx)
self.assertEqual(pg.sum(I), sum(idx))
bn = (np.array(idx) > 0) # numpy bool
idx = np.nonzero(bn)[0] # numpy int64
# numyp int64 -> IndexArray
I = pg.IndexArray(idx)
self.assertEqual(I.size(), 2)
self.assertEqual(pg.sum(I), sum(idx))
def test_NumpyToIndexArray(self):
'''
custom_rvalue.cpp
'''
x = np.array(range(10))
a = pg.IndexArray(x)
print(a)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(0, 10, dtype=np.int64)
a = pg.IndexArray(x)
print(a)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
def test_ListToRVector(self):
'''
custom_rvalue.cpp
'''
l = [1.0, 2.0, 3.0, 4.0]
a = pg.RVector(l)
self.assertEqual(a.size(), len(l))
self.assertEqual(pg.sum(a), sum(l))
l = (0.2, 0.3, 0.4, 0.5, 0.6)
x = pg.RVector(l)
self.assertEqual(x.size(), len(l))
def test_NumpyToIndexArray(self):
"""Implemented in custom_rvalue.cpp."""
x = np.array(range(10))
a = pg.IndexArray(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(0, 10, dtype=np.int64)
a = pg.IndexArray(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(0, 10, dtype="int")
a = pg.IndexArray(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.array([0, 100], dtype="int")
a = pg.IndexArray(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
def test_ListToRVector(self):
'''
custom_rvalue.cpp
'''
l = [1.0, 2.0, 3.0, 4.0]
a = pg.RVector(l)
self.assertEqual(a.size(), len(l))
self.assertEqual(pg.sum(a), sum(l))
l = (0.2, 0.3, 0.4, 0.5, 0.6)
x = pg.RVector(l)
self.assertEqual(x.size(), len(l))
def test_NumpyToIndexArray(self):
"""Implemented in custom_rvalue.cpp."""
x = np.array(range(10))
a = pg.IndexArray(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(0, 10, dtype=np.int64)
a = pg.IndexArray(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(0, 10, dtype="int")
a = pg.IndexArray(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.array([0, 100], dtype="int")
a = pg.IndexArray(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
def test_NumpyToIVector(self):
"""Implemented in custom_rvalue.cpp."""
x = np.array(range(-10, 10))
a = pg.IVector(x)
# pg.core.setDeepDebug(1)
# print(a)
# pg.core.setDeepDebug(0)
# sys.exit()
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(-10, 10, dtype=np.int64)
a = pg.IVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(-10, 10, dtype="int")
a = pg.IVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.array([-10, 100], dtype="int")
a = pg.IVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(10, dtype=np.long)
a = pg.IVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
self.assertEqual(pg.sum(x), sum(x))
def test_NumpyToRVector(self):
"""Implemented in custom_rvalue.cpp."""
x = np.arange(0, 1., 0.2)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(0, 1., 0.2, dtype=np.float64)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(10, dtype=np.int)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(10, dtype=np.long)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
self.assertEqual(pg.sum(x), sum(x))
def test_ListToRVector(self):
""" implemented in custom_rvalue.cpp"""
l = [1.0, 2.0, 3.0, 4.0]
a = pg.RVector(l)
self.assertEqual(a.size(), len(l))
self.assertEqual(pg.sum(a), sum(l))
l = (0.2, 0.3, 0.4, 0.5, 0.6)
x = pg.RVector(l)
self.assertEqual(x.size(), len(l))
l = [1, 2, 3]
x = pg.RVector(l)
self.assertEqual(x.size(), len(l))
def test_ListToRVector(self):
""" implemented in custom_rvalue.cpp"""
l = [1.0, 2.0, 3.0, 4.0]
a = pg.RVector(l)
self.assertEqual(a.size(), len(l))
self.assertEqual(pg.sum(a), sum(l))
l = (0.2, 0.3, 0.4, 0.5, 0.6)
x = pg.RVector(l)
self.assertEqual(x.size(), len(l))
l = [1, 2, 3]
x = pg.RVector(l)
self.assertEqual(x.size(), len(l))
def test_NumpyToRVector(self):
"""Implemented in custom_rvalue.cpp."""
x = np.arange(0, 1., 0.2)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(0, 1., 0.2, dtype=np.float64)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(10, dtype=np.int)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
x = np.arange(10, dtype=np.long)
a = pg.RVector(x)
self.assertEqual(a.size(), len(x))
self.assertEqual(pg.sum(a), sum(x))
self.assertEqual(pg.sum(x), sum(x))
def createJacobian(self, slowness):
"""Jacobian matrix using a fat-ray approach (Jordi et al. 2016)."""
data = self.data()
self.jacobian().resize(data.size(), self.mesh().cellCount())
# first compute reciprocal travel times for geophone sources
self.computeTravelTimes(slowness, calcOthers=True)
n_data = data.size()
cellSizes = self.mesh().cellSizes()
for i in range(n_data):
iS, iG = int(data("s")[i]), int(data("g")[i])
tsr = self.dataMatrix[iS][iG] # shot-receiver travel time
dt = self.timeMatrix[iS] + self.timeMatrix[iG] - tsr # difference
weight = np.maximum(1 - 2 * self.frequency * dt, 0.0) # 1 on ray
if self.debug:
print(pg.sum(pg.sign(weight)))
wa = weight * cellSizes
self.jacobian()[i] = wa / np.sum(wa) * tsr / slowness
def createJacobian(self, slowness):
"""Jacobian matrix using a fat-ray approach (Jordi et al. 2016)."""
data = self.data()
self.jacobian().resize(data.size(), self.mesh().cellCount())
# first compute reciprocal travel times for geophone sources
self.computeTravelTimes(slowness, calcOthers=True)
n_data = data.size()
cellSizes = self.mesh().cellSizes()
for i in range(n_data):
iS, iG = int(data("s")[i]), int(data("g")[i])
tsr = self.dataMatrix[iS][iG] # shot-receiver travel time
dt = self.timeMatrix[iS] + self.timeMatrix[iG] - tsr # difference
weight = np.maximum(1 - 2 * self.frequency * dt, 0.0) # 1 on ray
if self.debug:
print(pg.sum(pg.sign(weight)))
wa = weight * cellSizes
if np.sum(wa) > 0: # only if all values are zero
wa /= np.sum(wa)
self.jacobian()[i] = wa * tsr / slowness
def createJacobian(self, model):
"""Create Jacobian matrix."""
if self.subPotentials is None:
self.response(model)
J = self.jacobian()
J.resize(self.data.size(), self.regionManager().parameterCount())
cells = self.mesh().findCellByMarker(0, -1)
Si = pg.ElementMatrix()
St = pg.ElementMatrix()
u = self.subPotentials
pg.tic()
if self.verbose():
print("Calculate sensitivity matrix for model: ", min(model),
max(model))
Jt = pg.RMatrix(self.data.size(),
self.regionManager().parameterCount())
for kIdx, w in enumerate(self.w):
k = self.k[kIdx]
w = self.w[kIdx]
Jt *= 0.
A = pg.ElementMatrixMap()
for i, c in enumerate(cells):
modelIdx = c.marker()
# 2.5D
Si.u2(c)
Si *= k * k
Si += St.ux2uy2uz2(c)
# 3D
# Si.ux2uy2uz2(c); w = w* 2
A.add(modelIdx, Si)
for dataIdx in range(self.data.size()):
a = int(self.data('a')[dataIdx])
b = int(self.data('b')[dataIdx])
m = int(self.data('m')[dataIdx])
n = int(self.data('n')[dataIdx])
Jt[dataIdx] = A.mult(u[kIdx][a] - u[kIdx][b],
u[kIdx][m] - u[kIdx][n])
J += w * Jt
m2 = model * model
k = self.data('k')
for i in range(J.rows()):
J[i] /= (m2 / k[i])
if self.verbose():
sumsens = np.zeros(J.rows())
for i in range(J.rows()):
sumsens[i] = pg.sum(J[i])
print("sens sum: median = ", pg.median(sumsens), " min = ",
pg.min(sumsens), " max = ", pg.max(sumsens))
def createJacobian(self, model):
"""Create Jacobian matrix."""
if self.subPotentials is None:
self.response(model)
J = self.jacobian()
J.resize(self.data.size(), self.regionManager().parameterCount())
cells = self.mesh().findCellByMarker(0, -1)
Si = pg.ElementMatrix()
St = pg.ElementMatrix()
u = self.subPotentials
pg.tic()
if self.verbose():
print("Calculate sensitivity matrix for model: ",
min(model), max(model))
Jt = pg.RMatrix(self.data.size(),
self.regionManager().parameterCount())
for kIdx, w in enumerate(self.w):
k = self.k[kIdx]
w = self.w[kIdx]
Jt *= 0.
A = pg.ElementMatrixMap()
for i, c in enumerate(cells):
modelIdx = c.marker()
# 2.5D
Si.u2(c)
Si *= k * k
Si += St.ux2uy2uz2(c)
# 3D
# Si.ux2uy2uz2(c); w = w* 2
A.add(modelIdx, Si)
for dataIdx in range(self.data.size()):
a = int(self.data('a')[dataIdx])
b = int(self.data('b')[dataIdx])
m = int(self.data('m')[dataIdx])
n = int(self.data('n')[dataIdx])
Jt[dataIdx] = A.mult(u[kIdx][a] - u[kIdx][b],
u[kIdx][m] - u[kIdx][n])
J += w * Jt
m2 = model*model
k = self.data('k')
for i in range(J.rows()):
J[i] /= (m2 / k[i])
if self.verbose():
sumsens = np.zeros(J.rows())
for i in range(J.rows()):
sumsens[i] = pg.sum(J[i])
print("sens sum: median = ", pg.median(sumsens),
" min = ", pg.min(sumsens),
" max = ", pg.max(sumsens))
def test_IndexAccess(self):
I = pg.IndexArray([0,1,1,0])
np.testing.assert_array_equal(pg.sum(I), 2)
np.testing.assert_array_equal(sum(I), 2)
np.testing.assert_array_equal(np.sum(I), 2)
def test_IndexAccess(self):
# (double) array/vector
an = np.arange(10.)
ag = pg.Vector(an)
# bn = nd.array(bool)
bn = (an > 4.)
self.assertEqual(type(bn), np.ndarray)
self.assertEqual(bn.dtype, 'bool')
self.assertEqual(sum(bn), 5)
# bg = BVector
bg = (ag > 4.)
self.assertEqual(type(bg), pg.BVector)
self.assertEqual(sum(bg), 5)
# BVector(nd.array(bool))
self.assertEqual(len(bg), len(pg.BVector(bn)))
self.assertEqual(sum(bg), sum(pg.BVector(bn)))
self.assertEqual(bg[0], pg.BVector(bn)[0])
np.testing.assert_array_equal(bg, pg.BVector(bn))
# In = nd.array(int)
In = np.nonzero(bn)[0]
self.assertEqual(type(In), np.ndarray)
self.assertEqual(In.dtype, 'int64')
self.assertEqual(len(In), 5)
self.assertEqual(In[0], 5)
# np.nonzero(bg)
np.testing.assert_array_equal(In, np.nonzero(bg)[0])
# Ig = IndexArray
Ig = pg.find(bg)
self.assertEqual(type(Ig), pg.core.IndexArray)
self.assertEqual(len(Ig), 5)
self.assertEqual(Ig[0], 5)
# pg.find(nd.array(bool))
np.testing.assert_array_equal(Ig, pg.find(bn))
## Indexoperators ##
# ndarray [nd.array(bool)] == ndarray [nd.array(int)]
np.testing.assert_equal(an[bn], an[In])
self.assertEqual(len(an[bn]), 5)
self.assertEqual(an[bn][0], 5)
# ndarray[IndexArray] == ndarray [nd.array(int)]
np.testing.assert_equal(an[Ig], an[In])
# ndarray[BVector] == ndarray [nd.array(bool)]
np.testing.assert_array_equal(an[np.array(bg, dtype='bool')], an[bn])
np.testing.assert_array_equal(an[np.array(bg)], an[bn])
np.testing.assert_array_equal(an[bg.array()], an[bn])
np.testing.assert_array_equal(an[an>5], [6, 7, 8, 9])
np.testing.assert_array_equal(ag[bg], ag[Ig])
self.assertEqual(len(ag[bg]), 5)
self.assertEqual(ag[bg][0], 5)
# RVector [BVector] == RVector [nd.array(bool)]
np.testing.assert_array_equal(ag[bg], ag[bn])
np.testing.assert_equal(sum(ag[bg]), sum(ag[bn]))
# RVector [IndexArray] == RVector [nd.array(int)]
np.testing.assert_array_equal(ag[Ig], ag[In])
# RVector(BVector) == RVector(nd.array(bool))
# RVector(IndexArray) == RVector(nd.array(int))
I = pg.core.IndexArray([0,1,1,0])
np.testing.assert_array_equal(pg.sum(I), 2)
np.testing.assert_array_equal(sum(I), 2)
np.testing.assert_array_equal(np.sum(I), 2)
ab2 = np.logspace(-1, 2, 50) # AB/2 distance (current electrodes)
mn2 = ab2 / 3. # MN/2 distance (potential electrodes)
f = pg.DC1dModelling(nlay, ab2, mn2)
synres = [100., 500., 20., 800.] # synthetic resistivity
synthk = [0.5, 3.5, 6.] # synthetic thickness (nlay-th layer is infinite)
rhoa = f(synthk + synres)
rhoa = rhoa * (pg.randn(len(rhoa)) * errPerc / 100. + 1.)
transLog = pg.RTransLog()
inv = LSQRInversion(rhoa, f, transLog, transLog, True)
inv.setRelativeError(errPerc / 100)
startModel = pg.cat(pg.Vector(nlay - 1, 5),
pg.Vector(nlay, pg.median(rhoa)))
print(inv.response())
inv.setModel(startModel)
inv.setMarquardtScheme()
inv.setLambda(1000)
G = pg.RMatrix(rows=1, cols=len(startModel))
for i in range(3):
G[0][i] = 1
c = pg.Vector(1, pg.sum(synthk))
inv.setParameterConstraints(G, c, 100)
# print("Start", inv.chi2(), inv.relrms(), pg.sum(inv.model()(0, nlay-1)))
if 0:
for i in range(10):
inv.oneStep()
print(i, inv.chi2(), inv.relrms(), pg.sum(inv.model()(0,
nlay - 1)))
else:
inv.run()
print(inv.chi2(), inv.relrms(), pg.sum(inv.model()(0, nlay - 1)))
def test_IndexAccess(self):
I = pg.IndexArray([0, 1, 1, 0])
np.testing.assert_array_equal(pg.sum(I), 2)
np.testing.assert_array_equal(sum(I), 2)
np.testing.assert_array_equal(np.sum(I), 2)
