void test_create( const ecl_grid_type * grid , ecl_kw_type * fault_block_kw) {
int k = 0;
int i,j;
for (j=0; j < ecl_grid_get_ny( grid ); j++) {
for (i = 0; i < ecl_grid_get_nx( grid ); i++) {
int g = ecl_grid_get_global_index3( grid , i,j,k);
ecl_kw_iset_int( fault_block_kw , g , 9 );
}
}
{
fault_block_layer_type * layer = fault_block_layer_alloc( grid , k );
test_assert_int_equal( 1 , fault_block_layer_get_next_id( layer ));
fault_block_layer_scan_kw( layer , fault_block_kw);
{
fault_block_type * block = fault_block_layer_iget_block( layer , 0 );
double x,y,z;
ecl_grid_get_xyz3( grid , 4,4,k , &x, &y , &z );
test_assert_double_equal( x , fault_block_get_xc( block ));
test_assert_double_equal( y , fault_block_get_yc( block ));
}
fault_block_layer_free( layer );
}
}
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 test_neighbours( const ecl_grid_type * grid) {
const int k = 0;
fault_block_layer_type * layer = fault_block_layer_alloc( grid , k );
geo_polygon_collection_type * polylines = geo_polygon_collection_alloc();
ecl_kw_type * ecl_kw = ecl_kw_alloc("FAULTBLK" , ecl_grid_get_global_size( grid ) , ECL_INT_TYPE );
ecl_kw_iset_int( ecl_kw , 0 , 1);
ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 3,3,k) , 2);
ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 4,3,k) , 3);
ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 5,3,k) , 4);
ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 4,2,k) , 5);
fault_block_layer_load_kw( layer , ecl_kw);
{
int_vector_type * neighbours = int_vector_alloc( 0,0);
{
fault_block_type * block = fault_block_layer_get_block( layer , 1 );
test_assert_int_equal( 0 , int_vector_size( neighbours ));
fault_block_list_neighbours( block , false , polylines , neighbours );
test_assert_int_equal( 0 , int_vector_size( neighbours ));
}
{
fault_block_type * block = fault_block_layer_get_block( layer , 2 );
fault_block_list_neighbours( block , false , polylines , neighbours );
test_assert_int_equal( 1 , int_vector_size( neighbours ));
test_assert_true( int_vector_contains( neighbours , 3 ));
}
int_vector_free( neighbours );
}
geo_polygon_collection_free( polylines );
fault_block_layer_free( layer );
ecl_kw_free( ecl_kw );
}
void test_create( const ecl_grid_type * grid , const ecl_kw_type * fault_block_kw) {
test_assert_NULL( fault_block_layer_alloc( grid , -1 ));
test_assert_NULL( fault_block_layer_alloc( grid , ecl_grid_get_nz( grid )));
{
int k;
for (k = 0; k < ecl_grid_get_nz( grid ); k++) {
fault_block_layer_type * layer = fault_block_layer_alloc( grid , k);
test_assert_true( fault_block_layer_is_instance( layer ));
fault_block_layer_scan_kw( layer , fault_block_kw);
{
int max_block_id = fault_block_layer_get_max_id( layer );
int block_id;
for (block_id = 0; block_id <= max_block_id; block_id++) {
if (fault_block_layer_has_block( layer , block_id)) {
fault_block_type * block = fault_block_layer_get_block( layer , block_id );
fault_block_get_xc( block );
fault_block_get_yc( block );
}
}
}
{
int index;
for (index = 0; index < fault_block_layer_get_size( layer ); index++) {
fault_block_type * block = fault_block_layer_iget_block( layer , index );
fault_block_get_xc( block );
fault_block_get_yc( block );
}
}
fault_block_layer_free( layer );
}
}
}
void fault_block_layer_free__( void * arg ) {
fault_block_layer_type * layer = fault_block_layer_safe_cast( arg );
fault_block_layer_free( layer );
}
