def test_vector_operations_with_exceptions(self):
iv1 = IntVector()
iv1.append(1)
iv1.append(2)
iv1.append(3)
iv2 = IntVector()
iv2.append(4)
iv2.append(5)
dv1 = DoubleVector()
dv1.append(0.5)
dv1.append(0.75)
dv1.append(0.25)
# Size mismatch
with self.assertRaises(ValueError):
iv3 = iv1 + iv2
# Size mismatch
with self.assertRaises(ValueError):
iv3 = iv1 * iv2
# Type mismatch
with self.assertRaises(TypeError):
iv1 += dv1
# Type mismatch
with self.assertRaises(TypeError):
iv1 *= dv1
def test_element_sum(self):
dv = DoubleVector()
iv = IntVector()
for i in range(10):
dv.append(i + 1)
iv.append(i + 1)
self.assertEqual(dv.elementSum(), 55)
self.assertEqual(iv.elementSum(), 55)
def test_element_sum(self):
dv = DoubleVector()
iv = IntVector()
for i in range(10):
dv.append(i + 1)
iv.append(i + 1)
self.assertEqual(dv.elementSum(), 55)
self.assertEqual(iv.elementSum(), 55)
def get_edge_polygon(self):
x_list = DoubleVector()
y_list = DoubleVector()
cell_list = IntVector()
self._trace_edge(x_list, y_list, cell_list)
p = Polyline()
for (x, y) in zip(x_list, y_list):
p.addPoint(x, y)
return p
def getDepthValues(self, report_step):
"""@rtype: DoubleVector"""
block_obs = self.getBlockObservation(report_step)
depth = DoubleVector()
for index in block_obs:
value = block_obs.getDepth(index)
depth.append(value)
return depth
def test_stat_quantiles(self):
rng = RandomNumberGenerator()
rng.setState("0123456789ABCDEF")
v = DoubleVector()
for i in range(100000):
v.append(rng.getDouble())
self.assertAlmostEqual(quantile(v, 0.1), 0.1, 2)
self.assertAlmostEqual(quantile_sorted(v, 0.2), 0.2, 2)
self.assertAlmostEqual(quantile_sorted(v, 0.3), 0.3, 2)
self.assertAlmostEqual(quantile_sorted(v, 0.4), 0.4, 2)
self.assertAlmostEqual(quantile_sorted(v, 0.5), 0.5, 2)
def blocked_production(self, totalKey, timeRange):
node = self.smspec_node(totalKey)
if node.isTotal():
total = DoubleVector()
for t in timeRange:
if t < CTime(self.start_time):
total.append(0)
elif t >= CTime(self.end_time):
total.append(self.get_last_value(totalKey))
else:
total.append(self.get_interp(totalKey, date=t))
tmp = total << 1
total.pop()
return tmp - total
else:
raise TypeError(
"The blockedProduction method must be called with one of the TOTAL keys like e.g. FOPT or GWIT"
)
def test_true_false(self):
v = IntVector(default_value=77)
self.assertFalse(v)
v[10] = 77
self.assertTrue(v)
v = DoubleVector(default_value=77)
self.assertFalse(v)
v[10] = 77
self.assertTrue(v)
def center(self):
xlist = DoubleVector()
ylist = DoubleVector()
for segment in self:
C1 = segment.getC1()
C2 = segment.getC2()
(J1, I1) = divmod(C1, self.__grid.getNX() + 1)
(J2, I2) = divmod(C2, self.__grid.getNX() + 1)
(x1, y1, z) = self.__grid.getNodePos(I1, J1, self.__k)
(x2, y2, z) = self.__grid.getNodePos(I2, J2, self.__k)
xlist.append(x1)
xlist.append(x2)
ylist.append(y1)
ylist.append(y2)
N = len(xlist)
return (xlist.elementSum() / N, ylist.elementSum() / N)
def test_count_equal(self):
v = IntVector(default_value=77)
v[0] = 1
v[10] = 1
v[20] = 1
self.assertEqual(v.countEqual(1), 3)
v = DoubleVector(default_value=77)
v[0] = 1
v[10] = 1
v[20] = 1
self.assertEqual(v.countEqual(1), 3)
def test_vector_operations_with_exceptions(self):
iv1 = IntVector()
iv1.append(1)
iv1.append(2)
iv1.append(3)
iv2 = IntVector()
iv2.append(4)
iv2.append(5)
dv1 = DoubleVector()
dv1.append(0.5)
dv1.append(0.75)
dv1.append(0.25)
# Size mismatch
with self.assertRaises(ValueError):
iv3 = iv1 + iv2
# Size mismatch
with self.assertRaises(ValueError):
iv3 = iv1 * iv2
# Type mismatch
with self.assertRaises(TypeError):
iv1 += dv1
# Type mismatch
with self.assertRaises(TypeError):
iv1 *= dv1
def loadVector(self, plot_block_data, fs, report_step, realization_number):
"""
@type plot_block_data: PlotBlockData
@type fs: EnkfFs
@type report_step: int
@type realization_number: int
@rtype PlotBlockVector
"""
config_node = self.__obs_vector.getConfigNode()
is_private_container = (
config_node.getImplementationType() == ErtImplType.CONTAINER)
data_node = EnkfNode(config_node, private=is_private_container)
node_id = NodeId(report_step, realization_number)
if data_node.tryLoad(fs, node_id):
block_obs = self.getBlockObservation(report_step)
data = DoubleVector()
for index in range(len(block_obs)):
value = block_obs.getData(data_node.valuePointer(), index,
node_id)
data.append(value)
data.permute(self.__permutation_vector)
plot_block_vector = PlotBlockVector(realization_number, data)
plot_block_data.addPlotBlockVector(plot_block_vector)
def test_init_linear(self):
with self.assertRaises(ValueError):
v = IntVector.create_linear(0, 10, 1)
v = IntVector.create_linear(0, 10, 11)
for i in range(len(v)):
self.assertEqual(v[i], i)
v = IntVector.create_linear(10, 0, 11)
for i in range(len(v)):
self.assertEqual(v[i], 10 - i)
d = DoubleVector.create_linear(0, 1, 11)
for i in range(len(d)):
self.assertEqual(d[i], i * 0.10)
def setValues(self, values):
if len(values) == len(self):
if isinstance(values, DoubleVector):
self._set_values(d)
else:
d = DoubleVector()
for (index, v) in enumerate(values):
if isinstance(v, numbers.Number):
d[index] = v
else:
raise TypeError("Values must numeric: %s is invalid" %
v)
self._set_values(d)
else:
raise ValueError("Size mismatch between GenKW and values")
def test_gc_polyline(self):
# This should test that the elements in the collection can be
# safely accessed, even after the polyline objects p1 and p2
# from create_collection() have gone out of scope.
c = self.create_collection()
v = DoubleVector(initial_size=10000)
p1 = c[0]
tail = p1[-1]
self.assertEqual(tail, (2, 12))
self.assertEqual(p1.getName(), "POLY1")
p2 = c[1]
tail = p2[-1]
self.assertEqual(tail, (20, 120))
self.assertEqual(p2.getName(), "POLY2")
def test_init_linear(self):
with self.assertRaises(ValueError):
v = IntVector.create_linear(0, 10, 1)
v = IntVector.create_linear(0,10,11)
for i in range(len(v)):
self.assertEqual(v[i], i)
v = IntVector.create_linear(10,0,11)
for i in range(len(v)):
self.assertEqual(v[i], 10 - i)
d = DoubleVector.create_linear(0,1,11)
for i in range(len(d)):
self.assertEqual( d[i] , i*0.10)
def test_slicing(self):
dv = DoubleVector(initial_size=10)
for i in range(10):
dv[i] = 1.0 / (1 + i)
self.dotest_slicing(dv)
iv = IntVector(initial_size=10)
for i in range(10):
iv[i] = i**3
self.dotest_slicing(iv)
bv = BoolVector(initial_size=10)
for i in range(0, 10, 3):
bv[i] = True
self.dotest_slicing(bv)
tv = TimeVector(initial_size=10)
for i in range(10):
tv[i] = CTime(datetime.datetime(2016, 12, i + 3, 0, 0, 0))
self.dotest_slicing(tv)
def test_permutation_vector(self):
vector = DoubleVector()
for i in range(5, 0, -1):
vector.append(i)
permutation_vector = vector.permutationSort()
for index, value in enumerate(range(5, 0, -1)):
self.assertEqual(vector[index], value)
vector.permute(permutation_vector)
for index, value in enumerate(range(1, 6)):
self.assertEqual(vector[index], value)
def calculatePrincipalComponent(self,
fs,
local_obsdata,
truncation_or_ncomp=3):
pc = Matrix(1, 1)
pc_obs = Matrix(1, 1)
singular_values = DoubleVector()
state_map = fs.getStateMap()
ens_mask = BoolVector(False, self.ert().getEnsembleSize())
state_map.selectMatching(ens_mask, RealizationStateEnum.STATE_HAS_DATA)
active_list = ens_mask.createActiveList()
if len(ens_mask) > 0:
meas_data = MeasData(ens_mask)
obs_data = ObsData()
self.ert().getObservations().getObservationAndMeasureData(
fs, local_obsdata, active_list, meas_data, obs_data)
meas_data.deactivateZeroStdSamples(obs_data)
active_size = len(obs_data)
if active_size > 0:
S = meas_data.createS()
D_obs = obs_data.createDObs()
truncation, ncomp = self.truncationOrNumberOfComponents(
truncation_or_ncomp)
obs_data.scale(S, D_obs=D_obs)
EnkfLinalg.calculatePrincipalComponents(
S, D_obs, truncation, ncomp, pc, pc_obs, singular_values)
if self.__prior_singular_values is None:
self.__prior_singular_values = singular_values
else:
for row in range(pc.rows()):
factor = singular_values[
row] / self.__prior_singular_values[row]
pc.scaleRow(row, factor)
pc_obs.scaleRow(row, factor)
return PcaPlotData(local_obsdata.getName(), pc, pc_obs,
singular_values)
return None
def test_plot_block_vector(self):
vector = DoubleVector()
vector.append(1.5)
vector.append(2.5)
vector.append(3.5)
plot_block_vector = PlotBlockVector(1, vector)
self.assertEqual(plot_block_vector.getRealizationNumber(), 1)
self.assertEqual(plot_block_vector[0], 1.5)
self.assertEqual(plot_block_vector[2], 3.5)
self.assertEqual(len(plot_block_vector), len(vector))
def center(self):
xlist = DoubleVector()
ylist = DoubleVector()
for segment in self:
C1 = segment.getC1()
C2 = segment.getC2()
(J1, I1) = divmod(C1, self.__grid.getNX() + 1)
(J2, I2) = divmod(C2, self.__grid.getNX() + 1)
(x1,y1,z) = self.__grid.getNodePos(I1, J1, self.__k)
(x2,y2,z) = self.__grid.getNodePos(I2, J2, self.__k)
xlist.append(x1)
xlist.append(x2)
ylist.append(y1)
ylist.append(y2)
N = len(xlist)
return (xlist.elementSum()/N, ylist.elementSum()/N)
def test_permutation_vector(self):
vector = DoubleVector()
for i in range(5, 0, -1):
vector.append(i)
permutation_vector = vector.permutationSort()
for index, value in enumerate(range(5, 0, -1)):
self.assertEqual(vector[index], value)
vector.permute(permutation_vector)
for index, value in enumerate(range(1, 6)):
self.assertEqual(vector[index], value)
def test_plot_block_data(self):
depth = DoubleVector()
depth.append(2.5)
depth.append(3.5)
data = PlotBlockData(depth)
self.assertEqual(data.getDepth(), depth)
vector = PlotBlockVector(1, DoubleVector())
data.addPlotBlockVector(vector)
data.addPlotBlockVector(PlotBlockVector(2, DoubleVector()))
self.assertEqual(len(data), 2)
self.assertEqual(vector, data[1])
def test_polyfit(self):
x_list = DoubleVector()
y_list = DoubleVector()
S = DoubleVector()
A = 7.25
B = -4
C = 0.025
x = 0
dx = 0.1
for i in range(100):
y = A + B * x + C * x * x
x_list.append(x)
y_list.append(y)
x += dx
S.append(1.0)
beta = polyfit(3, x_list, y_list, None)
self.assertAlmostEqual(A, beta[0])
self.assertAlmostEqual(B, beta[1])
self.assertAlmostEqual(C, beta[2])
def get_interp_row(self, key_list, sim_time, invalid_value=-1):
ctime = CTime(sim_time)
data = DoubleVector(initial_size=len(key_list),
default_value=invalid_value)
EclSum._get_interp_vector(self, ctime, key_list, data)
return data
def getData(self):
data = DoubleVector()
self._export_data(data)
return data
class GridTest(EclTest):
def egrid_file(self):
return self.createTestPath("Statoil/ECLIPSE/Gurbat/ECLIPSE.EGRID")
def grid_file(self):
return self.createTestPath("Statoil/ECLIPSE/Gurbat/ECLIPSE.GRID")
def grdecl_file(self):
return self.createTestPath(
"Statoil/ECLIPSE/Gurbat/include/example_grid_sim.GRDECL")
def test_loadFromFile(self):
g1 = EclGrid.loadFromFile(self.egrid_file())
g2 = EclGrid.loadFromFile(self.grdecl_file())
self.assertTrue(isinstance(g1, EclGrid))
self.assertTrue(isinstance(g2, EclGrid))
def test_corner(self):
grid = EclGrid(self.egrid_file())
nx = grid.getNX()
ny = grid.getNY()
nz = grid.getNZ()
(x1, y1, z1) = grid.getCellCorner(0, ijk=(0, 0, 0))
(x2, y2, z2) = grid.getLayerXYZ(0, 0)
self.assertEqual(x1, x2)
self.assertEqual(y1, y2)
self.assertEqual(z1, z2)
(x1, y1, z1) = grid.getCellCorner(0, ijk=(0, 1, 0))
(x2, y2, z2) = grid.getLayerXYZ((nx + 1), 0)
self.assertEqual(x1, x2)
self.assertEqual(y1, y2)
self.assertEqual(z1, z2)
(x1, y1, z1) = grid.getCellCorner(1, ijk=(nx - 1, 0, 0))
(x2, y2, z2) = grid.getLayerXYZ(nx, 0)
self.assertEqual(x1, x2)
self.assertEqual(y1, y2)
self.assertEqual(z1, z2)
(x1, y1, z1) = grid.getCellCorner(4, ijk=(0, 0, nz - 1))
(x2, y2, z2) = grid.getLayerXYZ(0, nz)
self.assertEqual(x1, x2)
self.assertEqual(y1, y2)
self.assertEqual(z1, z2)
(x1, y1, z1) = grid.getCellCorner(7, ijk=(nx - 1, ny - 1, nz - 1))
(x2, y2, z2) = grid.getLayerXYZ((nx + 1) * (ny + 1) - 1, nz)
self.assertEqual(x1, x2)
self.assertEqual(y1, y2)
self.assertEqual(z1, z2)
with self.assertRaises(IndexError):
grid.getLayerXYZ(-1, 0)
with self.assertRaises(IndexError):
grid.getLayerXYZ((nx + 1) * (ny + 1), 0)
with self.assertRaises(IndexError):
grid.getLayerXYZ(0, -1)
with self.assertRaises(IndexError):
grid.getLayerXYZ(0, nz + 1)
def test_GRID(self):
grid = EclGrid(self.grid_file())
self.assertTrue(grid)
def test_EGRID(self):
grid = EclGrid(self.egrid_file())
self.assertTrue(grid)
dims = grid.getDims()
self.assertEqual(dims[0], grid.getNX())
self.assertEqual(dims[1], grid.getNY())
self.assertEqual(dims[2], grid.getNZ())
def create(self, filename, load_actnum=True):
fileH = copen(filename, "r")
specgrid = EclKW.read_grdecl(fileH,
"SPECGRID",
ecl_type=EclDataType.ECL_INT,
strict=False)
zcorn = EclKW.read_grdecl(fileH, "ZCORN")
coord = EclKW.read_grdecl(fileH, "COORD")
if load_actnum:
actnum = EclKW.read_grdecl(fileH,
"ACTNUM",
ecl_type=EclDataType.ECL_INT)
else:
actnum = None
mapaxes = EclKW.read_grdecl(fileH, "MAPAXES")
grid = EclGrid.create(specgrid, zcorn, coord, actnum, mapaxes=mapaxes)
return grid
def test_rect(self):
with TestAreaContext("python/grid-test/testRect"):
a1 = 1.0
a2 = 2.0
a3 = 3.0
grid = EclGrid.createRectangular((9, 9, 9), (a1, a2, a3))
grid.save_EGRID("rect.EGRID")
grid2 = EclGrid("rect.EGRID")
self.assertTrue(grid)
self.assertTrue(grid2)
(x, y, z) = grid.get_xyz(ijk=(4, 4, 4))
self.assertAlmostEqualList([x, y, z],
[4.5 * a1, 4.5 * a2, 4.5 * a3])
v = grid.cell_volume(ijk=(4, 4, 4))
self.assertFloatEqual(v, a1 * a2 * a3)
z = grid.depth(ijk=(4, 4, 4))
self.assertFloatEqual(z, 4.5 * a3)
g1 = grid.global_index(ijk=(2, 2, 2))
g2 = grid.global_index(ijk=(4, 4, 4))
(dx, dy, dz) = grid.distance(g2, g1)
self.assertAlmostEqualList([dx, dy, dz], [2 * a1, 2 * a2, 2 * a3])
self.assertTrue(
grid.cell_contains(2.5 * a1, 2.5 * a2, 2.5 * a3,
ijk=(2, 2, 2)))
#ijk = grid.find_cell(1.5 * a1 , 2.5 * a2 , 3.5 * a3)
#self.assertAlmostEqualList(ijk, [1, 2, 3])
def test_create(self):
grid = self.create(self.grdecl_file())
self.assertTrue(grid)
def test_grdecl_load(self):
with self.assertRaises(IOError):
grid = EclGrid.loadFromGrdecl("/file/does/not/exists")
with TestAreaContext("python/grid-test/grdeclLoad"):
with open("grid.grdecl", "w") as f:
f.write("Hei ...")
with self.assertRaises(ValueError):
grid = EclGrid.loadFromGrdecl("grid.grdecl")
actnum = IntVector(default_value=1, initial_size=1000)
actnum[0] = 0
g1 = EclGrid.createRectangular((10, 10, 10), (1, 1, 1),
actnum=actnum)
self.assertEqual(g1.getNumActive(), actnum.elementSum())
g1.save_EGRID("G.EGRID")
with open("grid.grdecl", "w") as f2:
f2.write("SPECGRID\n")
f2.write(" 10 10 10 \'F\' /\n")
with openEclFile("G.EGRID") as f:
with copen("grid.grdecl", "a") as f2:
coord_kw = f["COORD"][0]
coord_kw.write_grdecl(f2)
zcorn_kw = f["ZCORN"][0]
zcorn_kw.write_grdecl(f2)
actnum_kw = f["ACTNUM"][0]
actnum_kw.write_grdecl(f2)
g2 = EclGrid.loadFromGrdecl("grid.grdecl")
self.assertTrue(g1.equal(g2))
def test_ACTNUM(self):
g1 = self.create(self.grdecl_file())
g2 = self.create(self.grdecl_file(), load_actnum=False)
self.assertTrue(g1.equal(g2))
def test_time(self):
t0 = time.clock()
g1 = EclGrid(self.egrid_file())
t1 = time.clock()
t = t1 - t0
self.assertTrue(t < 1.0)
def test_save(self):
with TestAreaContext("python/grid-test/testSave"):
g1 = EclGrid(self.egrid_file())
g1.save_EGRID("test.EGRID")
g2 = EclGrid("test.EGRID")
self.assertTrue(g1.equal(g2))
g1.save_GRID("test.GRID")
g2 = EclGrid("test.GRID")
self.assertTrue(g1.equal(g2))
fileH = copen("test.grdecl", "w")
g1.save_grdecl(fileH)
fileH.close()
g2 = self.create("test.grdecl")
self.assertTrue(g1.equal(g2))
def test_raise_IO_error(self):
with self.assertRaises(IOError):
g = EclGrid("/does/not/exist.EGRID")
def test_boundingBox(self):
grid = EclGrid.createRectangular((10, 10, 10), (1, 1, 1))
with self.assertRaises(ValueError):
bbox = grid.getBoundingBox2D(layer=-1)
with self.assertRaises(ValueError):
bbox = grid.getBoundingBox2D(layer=11)
bbox = grid.getBoundingBox2D(layer=10)
self.assertEqual(bbox, ((0, 0), (10, 0), (10, 10), (0, 10)))
with self.assertRaises(ValueError):
grid.getBoundingBox2D(lower_left=(-1, 0))
with self.assertRaises(ValueError):
grid.getBoundingBox2D(lower_left=(6, 10))
bbox = grid.getBoundingBox2D(lower_left=(3, 3))
self.assertEqual(bbox, ((3, 3), (10, 3), (10, 10), (3, 10)))
with self.assertRaises(ValueError):
grid.getBoundingBox2D(lower_left=(3, 3), upper_right=(2, 2))
bbox = grid.getBoundingBox2D(lower_left=(3, 3), upper_right=(7, 7))
self.assertEqual(bbox, ((3, 3), (7, 3), (7, 7), (3, 7)))
@skipIf(EclTest.slowTestShouldNotRun(),
"Slow test of numActive large memory skipped!")
def test_num_active_large_memory(self):
case = self.createTestPath("Statoil/ECLIPSE/Gurbat/ECLIPSE")
vecList = []
for i in range(12500):
vec = DoubleVector()
vec[81920] = 0
vecList.append(vec)
grid1 = EclGrid(case)
grid2 = EclGrid(case)
self.assertEqual(grid1.getNumActive(), grid2.getNumActive())
self.assertEqual(grid1.getNumActive(), 34770)
def test_double_vector(self):
v = DoubleVector()
v[0] = 77.25
v[1] = 123.25
v[2] = 66.25
v[3] = 56.25
v[4] = 111.25
v[5] = 99.25
v[12] = 12
self.assertEqual(len(v), 13)
self.assertEqual(
list(v),
[
v[0], v[1], v[2], v[3], v[4], v[5], 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, v[12]
],
)
v.clear()
self.assertEqual(len(v), 0)
v.clear()
v[0] = 0.1
v[1] = 0.2
v[2] = 0.4
v[3] = 0.8
v2 = v * 2
self.assertEqual(list(v2), [v[0] * 2, v[1] * 2, v[2] * 2, v[3] * 2])
v2 += v
self.assertEqual(list(v2), [v[0] * 3, v[1] * 3, v[2] * 3, v[3] * 3])
v2.assign(0.66)
self.assertEqual(list(v2), [0.66, 0.66, 0.66, 0.66])
v.assign(v2)
self.assertEqual(list(v), [0.66, 0.66, 0.66, 0.66])
v.clear()
v.setDefault(0.75)
self.assertEqual(v.getDefault(), 0.75)
v[2] = 0.0
self.assertEqual(v[1], 0.75)
def test_double_vector(self):
v = DoubleVector()
v[0] = 77.25
v[1] = 123.25
v[2] = 66.25
v[3] = 56.25
v[4] = 111.25
v[5] = 99.25
v[12] = 12
self.assertEqual(len(v), 13)
self.assertEqual(list(v), [v[0], v[1], v[2], v[3], v[4], v[5], 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, v[12]])
v.clear()
self.assertEqual(len(v), 0)
v.clear()
v[0] = 0.1
v[1] = 0.2
v[2] = 0.4
v[3] = 0.8
v2 = v * 2
self.assertEqual(list(v2), [v[0] * 2, v[1] * 2, v[2] * 2, v[3] * 2])
v2 += v
self.assertEqual(list(v2), [v[0] * 3, v[1] * 3, v[2] * 3, v[3] * 3])
v2.assign(0.66)
self.assertEqual(list(v2), [0.66, 0.66, 0.66, 0.66])
v.assign(v2)
self.assertEqual(list(v), [0.66, 0.66, 0.66, 0.66])
v.clear()
v.setDefault(0.75)
self.assertEqual(v.getDefault(), 0.75)
v[2] = 0.0
self.assertEqual(v[1], 0.75)
