def test_NumpyToIVector(self):
"""Implemented in custom_rvalue.cpp."""
x = np.array(range(-10, 10))
a = pg.IVector(x)
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_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=int)
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_RVectorIndexRW(self):
v = pg.Vector(5, 2.0)
np.testing.assert_array_equal(v, [2, 2, 2, 2, 2])
v += 1.0
np.testing.assert_array_equal(v, [3, 3, 3, 3, 3])
v += 1
np.testing.assert_array_equal(v, [4, 4, 4, 4, 4])
v[1] = 1.0
np.testing.assert_array_equal(v, [4, 1, 4, 4, 4])
v[1] += 1.0
np.testing.assert_array_equal(v, [4, 2, 4, 4, 4])
v[[1,2]] = 2.0
np.testing.assert_array_equal(v, [4, 2, 2, 4, 4])
v[pg.IVector(1,3)] = 3.0
np.testing.assert_array_equal(v, [4, 2, 2, 3, 4])
v[pg.IVector(5,2)] = 1.0
np.testing.assert_array_equal(v, [4, 2, 1, 3, 4])
v[pg.find(v==4.0)] = 5.0
np.testing.assert_array_equal(v, [5, 2, 1, 3, 5])
v[v==5.0] = 4.0
np.testing.assert_array_equal(v, [4, 2, 1, 3, 4])
v[v==4.0] = 5.0
np.testing.assert_array_equal(v, [5, 2, 1, 3, 5])
#this will work only if we overwrite __iadd__
#v[v==4.0] += 1.0
#np.testing.assert_array_equal(v, [6, 2, 1, 3, 6])
v.setVal(1.0, 1)
np.testing.assert_array_equal(v, [5, 1, 1, 3, 5])
def setMesh(self, mesh, **kwargs): # secondaryNodes=3):
"""Set mesh and create additional secondary Nodes in cell centers."""
super().setMesh(mesh, **kwargs) # ignoreRegionManager=True)
print(self.mesh(), self.mesh().secondaryNodeCount())
self.mids = pg.IVector()
self.nnodes = self.mesh().nodeCount()
for c in self.mesh().cells():
n = self.mesh().createSecondaryNode(c.center())
c.addSecondaryNode(n)
self.mids.push_back(n.id())
print(self.mesh())
def test_IVectorOP(self):
v = pg.IVector(5, 1)
# print(v + 2)
# print(v - 2)
# print(2 * v)
#print(v * 2)
#self.assertEqual(sum(v * 2), 10)
self.assertEqual(sum(v + 1), 10)
self.assertEqual(sum(v - 2), -5)
#self.assertEqual(sum(v * 2), 10)
self.assertEqual(sum(v / 1), 5)
self.assertEqual(sum(1 + v), 10)
self.assertEqual(sum(-1 - v), -10)
self.assertEqual(sum(2 * v), 10)
self.assertEqual(sum(1 / v), 5)
def test_XVectorBasics(self):
def testVector(v):
for t in v:
self.assertEqual(t, 1.0)
self.assertEqual(sum(v), 5.0)
self.assertFalse(pg.haveInfNaN(v))
v[1] = 0
self.assertEqual(v[1], 0)
v[1] = 1
self.assertEqual(v[1], 1)
#print(v/v)
testVector(pg.RVector(5, 1.0))
testVector(pg.CVector(5, 1.0))
testVector(pg.BVector(5, True))
testVector(pg.IVector(5, 1))
def test_IVectorOP(self):
v = pg.IVector(5, 1)
# print(v + 2)
# print(v - 2)
# print(2 * v)
#print(v * 2)
#self.assertEqual(sum(v * 2), 10)
self.assertEqual(sum(v + 1), 10)
self.assertEqual(sum(v - 2), -5)
self.assertEqual(sum(v / 1), 5)
self.assertEqual(sum(1 + v), 10)
self.assertEqual(sum(-1 - v), -10)
self.assertEqual(sum(1 / v), 5)
# no clue why this doesnt work .. we might could hack them if someone need it
#self.assertEqual(sum(v * 2), 10)
self.assertEqual(sum(v + v), 10)
self.assertEqual(sum(v * v), 5)
self.assertEqual(sum(v - v), 0)
self.assertEqual(sum(v / v), 5)
self.assertEqual(sum(2 * v), 10)
schemeName='dd')
meshERT = mt.createParaMesh(ertScheme,
quality=33,
paraMaxCellSize=0.2,
boundaryMaxCellSize=50,
smooth=[1, 2])
pg.show(meshERT)
################################################################################
# Use simulated concentrations to calculate bulk resistivity using Archie's Law
# and fill matrix with apparent resistivity ratios with respect to a background
# model:
# Select 10 time frame to simulate ERT data
timesERT = pg.IVector(np.floor(np.linspace(0, len(c) - 1, 10)))
# Create conductivity of fluid for salt concentration $c$
sigmaFluid = c[timesERT] * 0.1 + 0.01
# Calculate bulk resistivity based on Archie's Law
resBulk = petro.resistivityArchie(rFluid=1. / sigmaFluid,
porosity=0.3,
m=1.3,
mesh=mesh,
meshI=meshERT,
fill=1)
# apply background resistivity model
rho0 = np.zeros(meshERT.cellCount()) + 1000.
for c in meshERT.cells():
