void test_export( const ecl_grid_type * grid) {
fault_block_layer_type * layer = fault_block_layer_alloc( grid , 0 );
ecl_kw_type * ecl_kw1 = ecl_kw_alloc("FAULTBLK" , ecl_grid_get_global_size( grid ) , ECL_INT_TYPE );
ecl_kw_type * ecl_kw2 = ecl_kw_alloc("FAULTBLK" , ecl_grid_get_global_size( grid ) + 1 , ECL_INT_TYPE );
ecl_kw_type * ecl_kw3 = ecl_kw_alloc("FAULTBLK" , ecl_grid_get_global_size( grid ) , ECL_FLOAT_TYPE );
fault_block_type * block = fault_block_layer_add_block( layer , 10 );
fault_block_add_cell( block , 0 , 0 );
fault_block_add_cell( block , 1 , 0 );
fault_block_add_cell( block , 1 , 1 );
fault_block_add_cell( block , 0 , 1 );
test_assert_true( fault_block_layer_export( layer , ecl_kw1 ));
test_assert_false( fault_block_layer_export( layer , ecl_kw2 ));
test_assert_false( fault_block_layer_export( layer , ecl_kw3 ));
{
int nx = ecl_grid_get_nx( grid );
test_assert_int_equal( ecl_kw_iget_int( ecl_kw1 , 0 ) , 10 );
test_assert_int_equal( ecl_kw_iget_int( ecl_kw1 , 1 ) , 10 );
test_assert_int_equal( ecl_kw_iget_int( ecl_kw1 , nx ) , 10 );
test_assert_int_equal( ecl_kw_iget_int( ecl_kw1 , nx + 1 ) , 10 );
}
test_assert_int_equal( 40 , ecl_kw_element_sum_int( ecl_kw1 ));
fault_block_layer_free( layer );
ecl_kw_free( ecl_kw1 );
ecl_kw_free( ecl_kw2 );
ecl_kw_free( ecl_kw3 );
}
void fault_block_layer_scan_layer( fault_block_layer_type * fault_layer , layer_type * layer) {
int i,j;
int_vector_type * i_list = int_vector_alloc(0,0);
int_vector_type * j_list = int_vector_alloc(0,0);
for (j = 0; j < layer_get_ny( layer ); j++) {
for (i = 0; i < layer_get_nx( layer); i++) {
int cell_value = layer_iget_cell_value( layer , i , j );
if (cell_value != 0) {
layer_trace_block_content( layer , true , i , j , cell_value , i_list , j_list );
{
int c;
int block_id = fault_block_layer_get_next_id( fault_layer );
fault_block_type * fault_block = fault_block_layer_add_block( fault_layer , block_id );
for (c=0; c < int_vector_size( i_list ); c++)
fault_block_add_cell( fault_block , int_vector_iget( i_list , c ), int_vector_iget( j_list , c ));
}
}
}
}
int_vector_free( i_list );
int_vector_free( j_list );
}
fault_block_type * fault_block_layer_safe_get_block( fault_block_layer_type * layer , int block_id) {
int storage_index = int_vector_safe_iget( layer->block_map , block_id);
if (storage_index < 0)
return fault_block_layer_add_block( layer , block_id );
else
return (fault_block_type*)vector_iget( layer->blocks , storage_index );
}
bool fault_block_layer_load_kw( fault_block_layer_type * layer , const ecl_kw_type * fault_block_kw) {
if (ecl_kw_get_size( fault_block_kw) != ecl_grid_get_global_size(layer->grid))
return false;
else if (!ecl_type_is_int(ecl_kw_get_data_type( fault_block_kw )))
return false;
else {
int i,j;
for (j=0; j < ecl_grid_get_ny( layer->grid ); j++) {
for (i=0; i < ecl_grid_get_nx( layer->grid ); i++) {
int g = ecl_grid_get_global_index3( layer->grid , i , j , layer->k );
int block_id = ecl_kw_iget_int( fault_block_kw , g );
if (block_id > 0) {
fault_block_layer_add_block( layer , block_id );
{
fault_block_type * fault_block = fault_block_layer_get_block( layer , block_id );
fault_block_add_cell( fault_block , i,j );
}
}
}
}
return true;
}
}
void fault_block_layer_insert_block_content( fault_block_layer_type * layer , const fault_block_type * src_block) {
int next_block_id = fault_block_layer_get_next_id( layer );
fault_block_type * target_block = fault_block_layer_add_block( layer , next_block_id );
fault_block_copy_content( target_block , src_block );
}
