def test_matrix_set(self):
m1 = Matrix(2,2)
m1.setAll(99)
self.assertEqual( 99 , m1[0,0] )
self.assertEqual( 99 , m1[1,1] )
m2 = Matrix(2,2 , value = 99)
self.assertEqual(m1,m2)
def test_copy_equal(self):
m1 = Matrix(2, 2)
m1[0,0] = 0
m1[0,1] = 1
m1[1,0] = 2
m1[1,1] = 3
m2 = m1.copy( )
self.assertTrue( m1 == m2 )
def __sortFaultLines(self):
"""A fault can typically consist of several non connected fault
segments; right after reading the fault input these can be in
a complete mess:
1. The different part of the fault can be in random order.
2. Within each fault line the micro segments can be ordered in
reverse.
This method goes through some desparate heuristics trying to sort
things out.
"""
N = len(self.__fault_lines)
x = Matrix(N, 1)
y = Matrix(N, 1)
for index,line in enumerate(self.__fault_lines):
xc,yc = line.center()
x[index,0] = xc
y[index,0] = yc
# y = beta[0] + beta[1] * x
# = a + b * x
beta = stat.polyfit(2, x, y)
a = beta[0]
b = beta[1]
perm_list = []
for index,line in enumerate(self.__fault_lines):
x0, y0 = line.center()
d = x0 + b*(y0 - a)
perm_list.append((index, d))
perm_list.sort(key=lambda x: x[1])
fault_lines = []
for (index,d) in perm_list:
fault_lines.append(self.__fault_lines[ index ])
self.__fault_lines = fault_lines
for line in self.__fault_lines:
x1,y1 = line.startPoint()
x2,y2 = line.endPoint()
d1 = x1 + b*(y1 - a)
d2 = x2 + b*(y2 - a)
if d1 > d2:
line.reverse()
def update(rng, mask, module, ert, meas_data, obs_data, state_size):
S = meas_data.createS()
R = obs_data.createR()
dObs = obs_data.createDObs()
E = obs_data.createE(rng, meas_data.getActiveEnsSize())
D = obs_data.createD(E, S)
obs_data.scale(S, E=E, D=D, R=R, D_obs=dObs)
A = Matrix(state_size, meas_data.getActiveEnsSize())
A.randomInit(rng)
module.initUpdate(mask, S, R, dObs, E, D)
module.updateA(A, S, R, dObs, E, D)
def init_matrices(ens , mask , obs , rng):
state_size = 2
report_step = 5
meas_data = MeasData( mask )
meas_block = meas_data.addBlock("OBS" , report_step , len(obs) )
A = Matrix( state_size , mask.countEqual( True ))
active_iens = 0
for iens,params in enumerate( ens ):
if mask[iens]:
state = forward_model( params )
meas_block[0,iens] = measure( state )
A[0 , active_iens] = params[0]
A[1 , active_iens] = params[1]
active_iens += 1
S = meas_data.createS()
obs_data = ObsData()
obs_block = obs_data.addBlock("OBS" , 1)
for iobs,obs_value in enumerate(obs):
obs_block[iobs] = obs_value
R = obs_data.createR()
dObs = obs_data.createDObs()
E = obs_data.createE( rng , meas_data.getActiveEnsSize() )
D = obs_data.createD(E , S)
obs_data.scale(S , E = E , D = D , R = R , D_obs = dObs)
return (A , S , E , D , R , dObs)
def test_analysis_module(self):
rng = RandomNumberGenerator( )
module = self.createAnalysisModule()
ens_size = 12
obs_size = 1
state_size = 2
true_params = [1.25 , 0.75]
true_state = forward_model( true_params )
obs = [(measure( true_state ) , 0.75)]
A = Matrix( state_size , ens_size )
ens = []
for iens in range(ens_size):
param = [ random.gauss( 1.00 , 1.00 ) , random.gauss(1.00 , 1.00)]
ens.append( param )
mask = BoolVector(default_value = True , initial_size = ens_size)
mask[2] = False
(A , S , E , D , R , dObs) = init_matrices( ens , mask , obs , rng )
module.initUpdate( mask , S , R , dObs , E , D )
module.updateA( A , S , R , dObs , E , D )
mask[10] = False
mask[5] = False
(A , S , E , D , R , dObs) = init_matrices( ens , mask , obs , rng )
self.assertEqual( S.dims() , (obs_size , mask.countEqual( True )))
self.assertEqual( E.dims() , (obs_size , mask.countEqual( True )))
self.assertEqual( D.dims() , (obs_size , mask.countEqual( True )))
module.initUpdate( mask , S , R , dObs , E , D )
module.updateA( A , S , R , dObs , E , D )
def polyfit(n, x, y, s=None):
"""
@type n: int
@type x: Matrix or Sequence
@type y: Matrix or Sequence
@type s: Matrix or Sequence or None
@return: tuple
"""
if _polyfit is None:
raise NotImplementedError("Sorry - your ert distribution has been built without lapack support")
if isinstance(x, Matrix):
xm = x
else:
xm = Matrix(len(x), 1)
for i in range(len(x)):
xm[i, 0] = x[i]
if isinstance(y, Matrix):
ym = y
else:
ym = Matrix(len(y), 1)
for i in range(len(y)):
ym[i, 0] = y[i]
if s:
if isinstance(s, Matrix):
sm = s
else:
sm = Matrix(len(s), 1)
for i in range(len(s)):
sm[i, 0] = s[i]
else:
sm = s
beta = Matrix(n, 1)
res = _polyfit(beta, xm, ym, sm)
if not res == LLSQResultEnum.LLSQ_SUCCESS:
raise Exception("Linear Least Squares Estimator failed?")
l = []
for i in range(n):
l.append(beta[i, 0])
return tuple(l)
def test_transpose(self):
m = Matrix(3,2)
m[0,0] = 0
m[1,0] = 2
m[2,0] = 4
m[0,1] = 1
m[1,1] = 3
m[2,1] = 5
mt = m.transpose( )
self.assertEqual(m[0,0] , 0)
self.assertEqual(m[1,0] , 2)
self.assertEqual(m[2,0] , 4)
self.assertEqual(m[0,1] , 1)
self.assertEqual(m[1,1] , 3)
self.assertEqual(m[2,1] , 5)
self.assertEqual( mt.rows() , m.columns())
self.assertEqual( mt.columns() , m.rows())
self.assertEqual(mt[0,0] , 0)
self.assertEqual(mt[1,0] , 1)
self.assertEqual(mt[0,1] , 2)
self.assertEqual(mt[1,1] , 3)
self.assertEqual(mt[0,2] , 4)
self.assertEqual(mt[1,2] , 5)
m.transpose( inplace = True )
self.assertEqual( m , mt )
def construct_matrix(self, n, vals):
"""Constructs n*n matrix with vals as entries"""
self.assertEqual(n * n, len(vals))
m = Matrix(n, n)
idx = 0
for i in range(n):
for j in range(n):
m[(i, j)] = vals[idx]
idx += 1
return m
def test_matrix_equality(self):
m = Matrix(2, 2)
m[0, 0] = 2
m[1, 1] = 4
s = Matrix(2, 3)
s[0, 0] = 2
s[1, 1] = 4
self.assertNotEqual(m, s)
r = Matrix(2, 2)
r[0, 0] = 2
r[1, 1] = 3
self.assertNotEqual(m, r)
r[1, 1] = 4
self.assertEqual(m, r)
def test_str(self):
m = Matrix(2, 2)
s = "%s" % m
m[0,0] = 0
m[0,1] = 1
m[1,0] = 2
m[1,1] = 3
with TestAreaContext("matrix_fprint"):
with open("matrix.txt", "w") as f:
m.fprint( f )
with open("matrix.txt") as f:
l1 = [ float(x) for x in f.readline().split()]
l2 = [ float(x) for x in f.readline().split()]
self.assertEqual( l1[0] , m[0,0])
self.assertEqual( l1[1] , m[0,1])
self.assertEqual( l2[0] , m[1,0])
self.assertEqual( l2[1] , m[1,1])
def test_matrix(self):
m = Matrix(2, 3)
self.assertEqual(m.rows(), 2)
self.assertEqual(m.columns(), 3)
self.assertEqual(m[(0, 0)], 0)
m[(1, 1)] = 1.5
self.assertEqual(m[(1, 1)], 1.5)
m[1,0] = 5
self.assertEqual(m[1, 0], 5)
with self.assertRaises(TypeError):
m[5] = 5
with self.assertRaises(IndexError):
m[2, 0] = 0
with self.assertRaises(IndexError):
m[0, 3] = 0
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_sub_copy(self):
m1 = Matrix(3,3)
rng = RandomNumberGenerator(RngAlgTypeEnum.MZRAN, RngInitModeEnum.INIT_DEFAULT)
m1.randomInit( rng )
with self.assertRaises(ValueError):
m2 = m1.subCopy( 0,0,4,2 )
with self.assertRaises(ValueError):
m2 = m1.subCopy( 0,0,2,4 )
with self.assertRaises(ValueError):
m2 = m1.subCopy( 4,0,1,1 )
with self.assertRaises(ValueError):
m2 = m1.subCopy( 0,2,1,2 )
m2 = m1.subCopy( 0,0,2,2 )
for i in range(2):
for j in range(2):
self.assertEqual( m1[i,j] , m2[i,j])
def test_num_PC(self):
S = Matrix(3, 3)
S[0, 0] = 1
S[1, 1] = 1
S[2, 2] = 1
with self.assertRaises(ValueError):
num_pc = Linalg.numPC(S, 0)
with self.assertRaises(ValueError):
num_pc = Linalg.numPC(S, 1.5)
num_pc = Linalg.numPC(S, 0.20)
self.assertEqual(num_pc, 1)
num_pc = Linalg.numPC(S, 0.50)
self.assertEqual(num_pc, 2)
num_pc = Linalg.numPC(S, 0.80)
self.assertEqual(num_pc, 3)
def test_matmul(self):
m1 = Matrix(3,3)
m2 = Matrix(2,2)
with self.assertRaises(ValueError):
Matrix.matmul( m1 , m2 )
m = Matrix(3,2)
m[0,0] = 0
m[1,0] = 2
m[2,0] = 4
m[0,1] = 1
m[1,1] = 3
m[2,1] = 5
mt = m.transpose( )
m2 = Matrix.matmul( m , mt )
self.assertEqual( m2[0,0] , 1 )
self.assertEqual( m2[1,1] , 13 )
self.assertEqual( m2[2,2] , 41 )
def test_identity(self):
m1 = Matrix.identity(1)
self.assertEqual(m1.rows(), 1)
self.assertEqual(m1.columns(), 1)
self.assertEqual(m1[0,0], 1)
with self.assertRaises(ValueError):
Matrix.identity(0)
with self.assertRaises(ValueError):
Matrix.identity(-3)
m = Matrix.identity(17)
self.assertEqual(m.rows(), 17)
self.assertEqual(m.columns(), 17)
for i in range(17):
for j in range(17):
elt = m[i, j]
if i == j:
self.assertEqual(elt, 1)
else:
self.assertEqual(elt, 0)
def test_matrix_random_init(self):
m = Matrix(10,10)
rng = RandomNumberGenerator(RngAlgTypeEnum.MZRAN, RngInitModeEnum.INIT_DEFAULT)
m.randomInit( rng )
def test_csv(self):
m = Matrix(2, 2)
m[0, 0] = 2
m[1, 1] = 4
with TestAreaContext("matrix_csv"):
m.dumpCSV("matrix.csv")
def _n_identity_mcs(self, n=6, s=3):
"""return n copies of the identity matrix on s*s elts"""
return tuple([Matrix.identity(s) for i in range(n)])
def test_matrix_scale(self):
m = Matrix(2,2 , value = 1)
m.scaleColumn(0 , 2)
self.assertEqual(2 , m[0,0])
self.assertEqual(2 , m[1,0])
m.setAll(1)
m.scaleRow(1 , 2 )
self.assertEqual(2 , m[1,0])
self.assertEqual(2 , m[1,1])
with self.assertRaises(IndexError):
m.scaleColumn(10 , 99)
with self.assertRaises(IndexError):
m.scaleRow(10 , 99)
def test_matrix_copy_column(self):
m = Matrix(10,2)
rng = RandomNumberGenerator(RngAlgTypeEnum.MZRAN, RngInitModeEnum.INIT_DEFAULT)
m.randomInit( rng )
with self.assertRaises(ValueError):
m.copyColumn(0,2)
with self.assertRaises(ValueError):
m.copyColumn(2,0)
with self.assertRaises(ValueError):
m.copyColumn(-2,0)
m.copyColumn(1, 0)
for i in range(m.rows()):
self.assertEqual( m[i,0] , m[i,1] )
def initX(self, A, S, R, dObs, E, D):
X = Matrix(A.columns(), A.columns())
self._initX(X, A, S, R, dObs, E, D)
return X