int main( int argc , char ** argv) {
const char * egrid_file = argv[1];
ecl_grid_type * grid = ecl_grid_alloc( egrid_file );
ecl_file_type * gfile = ecl_file_open( egrid_file , 0 );
const ecl_kw_type * nnc1_kw = ecl_file_iget_named_kw( gfile , "NNC1" ,0 );
const ecl_kw_type * nnc2_kw = ecl_file_iget_named_kw( gfile , "NNC2" ,0 );
const int_vector_type * index_list = ecl_grid_get_nnc_index_list( grid );
{
int_vector_type * nnc = int_vector_alloc(0,0);
int_vector_set_many( nnc , 0 , ecl_kw_get_ptr( nnc1_kw ) , ecl_kw_get_size( nnc1_kw ));
int_vector_append_many( nnc , ecl_kw_get_ptr( nnc2_kw ) , ecl_kw_get_size( nnc2_kw ));
int_vector_select_unique( nnc );
test_assert_int_equal( int_vector_size( index_list ) , int_vector_size( nnc ));
{
int i;
for (i=0; i < int_vector_size( nnc ); i++)
test_assert_int_equal( int_vector_iget( nnc , i ) - 1 , int_vector_iget(index_list , i ));
}
int_vector_free( nnc );
}
ecl_file_close( gfile );
ecl_grid_free( grid );
exit(0);
}
bool layer_trace_block_edge( const layer_type * layer , int start_i , int start_j , int value , struct_vector_type * corner_list , int_vector_type * cell_list) {
int g = layer_get_global_cell_index( layer , start_i , start_j);
cell_type * cell = &layer->data[g];
if ((cell->cell_value == value)) {
int i = start_i;
int j = start_j;
if (layer_find_edge( layer , &i , &j , value)) {
int_point2d_type start_corner;
g = layer_get_global_cell_index( layer , i , j);
cell = &layer->data[g];
start_corner.i = i;
start_corner.j = j;
struct_vector_reset( corner_list );
int_vector_reset( cell_list );
if (cell->edges[BOTTOM_EDGE] == value) {
point_shift( &start_corner , 0 , 0 );
layer_trace_block_edge__(layer , start_corner , i , j , value , BOTTOM_EDGE , corner_list , cell_list);
} else if (cell->edges[RIGHT_EDGE] == value) {
point_shift( &start_corner , 1 , 0 );
layer_trace_block_edge__(layer , start_corner , i , j , value , RIGHT_EDGE , corner_list , cell_list);
} else if (cell->edges[TOP_EDGE] == -value) {
point_shift( &start_corner , 1 , 1 );
layer_trace_block_edge__(layer , start_corner , i , j , value , TOP_EDGE , corner_list , cell_list);
} else if (cell->edges[LEFT_EDGE] == -value) {
point_shift( &start_corner , 0 , 1 );
layer_trace_block_edge__(layer , start_corner , i , j , value , LEFT_EDGE , corner_list , cell_list);
} else
util_abort("%s: what the f**k - internal error \n",__func__);
int_vector_select_unique( cell_list );
return true;
}
}
return false;
}
void bootstrap_enkf_updateA(void * module_data ,
matrix_type * A ,
matrix_type * S ,
matrix_type * R ,
matrix_type * dObs ,
matrix_type * E ,
matrix_type * D ) {
bootstrap_enkf_data_type * bootstrap_data = bootstrap_enkf_data_safe_cast( module_data );
{
const int num_cpu_threads = 4;
int ens_size = matrix_get_columns( A );
matrix_type * X = matrix_alloc( ens_size , ens_size );
matrix_type * A0 = matrix_alloc_copy( A );
matrix_type * S_resampled = matrix_alloc_copy( S );
matrix_type * A_resampled = matrix_alloc( matrix_get_rows(A0) , matrix_get_columns( A0 ));
int ** iens_resample = alloc_iens_resample( bootstrap_data->rng , ens_size );
{
int ensemble_members_loop;
for ( ensemble_members_loop = 0; ensemble_members_loop < ens_size; ensemble_members_loop++) {
int unique_bootstrap_components;
int ensemble_counter;
/* Resample A and meas_data. Here we are careful to resample the working copy.*/
{
{
int_vector_type * bootstrap_components = int_vector_alloc( ens_size , 0);
for (ensemble_counter = 0; ensemble_counter < ens_size; ensemble_counter++) {
int random_column = iens_resample[ ensemble_members_loop][ensemble_counter];
int_vector_iset( bootstrap_components , ensemble_counter , random_column );
matrix_copy_column( A_resampled , A0 , ensemble_counter , random_column );
matrix_copy_column( S_resampled , S , ensemble_counter , random_column );
}
int_vector_select_unique( bootstrap_components );
unique_bootstrap_components = int_vector_size( bootstrap_components );
int_vector_free( bootstrap_components );
}
if (bootstrap_data->doCV) {
const bool_vector_type * ens_mask = NULL;
cv_enkf_init_update( bootstrap_data->cv_enkf_data , ens_mask , S_resampled , R , dObs , E , D);
cv_enkf_initX( bootstrap_data->cv_enkf_data , X , A_resampled , S_resampled , R , dObs , E , D);
} else
std_enkf_initX(bootstrap_data->std_enkf_data , X , NULL , S_resampled,R, dObs, E,D );
matrix_inplace_matmul_mt1( A_resampled , X , num_cpu_threads );
matrix_inplace_add( A_resampled , A0 );
matrix_copy_column( A , A_resampled, ensemble_members_loop, ensemble_members_loop);
}
}
}
free_iens_resample( iens_resample , ens_size);
matrix_free( X );
matrix_free( S_resampled );
matrix_free( A_resampled );
matrix_free( A0 );
}
}
void test_empty() {
int_vector_type * vec = int_vector_alloc(0,0);
int_vector_sort( vec );
int_vector_select_unique( vec );
int_vector_free( vec );
}
