コード例 #1
0
int main(int argc , char ** argv) {
  util_install_signals();
  {
    ecl_grid_type * grid = ecl_grid_alloc( argv[1] );
    vector_type * expected = load_expected( grid, argv[2] );

    for (int c=0; c < vector_get_size( expected ); c++) {
      const point_type * p = vector_iget_const( expected , c );
      int g = ecl_grid_get_global_index_from_xyz(grid , p->x, p->y , p->z , 0 );
      if (g != ecl_grid_get_global_index3(grid, p->i,p->j, p->k)) {
        int i,j,k;
        ecl_grid_get_ijk1(grid, g, &i, &j, &k);
        fprintf(stderr,"point:%d   (%g,%g,%g), Simulated: %d:(%d,%d,%d)   Expected: %d:(%d,%d,%d)  contains:%d\n",
                c , p->x, p->y, p->z, g, i,j,k, p->g, p->i, p->j, p->k, ecl_grid_cell_contains_xyz1( grid, p->g , p->x , p->y, p->z));
      }
      if (!p->skip)
        test_assert_int_equal( g , ecl_grid_get_global_index3(grid, p->i,p->j, p->k));
      else {
        if ( g != ecl_grid_get_global_index3(grid, p->i,p->j, p->k))
          fprintf(stderr," ** Skipping failed test for point:%d \n",c);
      }
    }
    ecl_grid_free( grid );
    vector_free( expected );
  }
  exit(0);
}
コード例 #2
0
ファイル: ecl_fault_block_layer.c プロジェクト: agchitu/ert
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 );
  }
}
コード例 #3
0
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;
  }
}
コード例 #4
0
bool fault_block_layer_scan_kw( fault_block_layer_type * layer , const ecl_kw_type * fault_block_kw) {
  bool assign_zero = true;

  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;
    int max_block_id = 0;
    layer_type * work_layer = layer_alloc( ecl_grid_get_nx( layer->grid ) , ecl_grid_get_ny( layer->grid ));

    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) {
          layer_iset_cell_value( work_layer , i , j , block_id );
          max_block_id = util_int_max( block_id , max_block_id );
        }
      }
    }

    if (assign_zero)
      layer_replace_cell_values( work_layer , 0 , max_block_id + 1);

    fault_block_layer_scan_layer( layer , work_layer );
    layer_free( work_layer );
    return true;
  }
}
コード例 #5
0
vector_type * load_expected( const ecl_grid_type * grid, const char * filename ) {
  FILE * stream = util_fopen( filename , "r");
  vector_type * expected = vector_alloc_new();

  while (true) {
    double x,y,z;
    int i,j,k,skip;

    if (fscanf( stream , "%lg %lg %lg %d %d %d %d" , &x,&y,&z,&i,&j,&k,&skip) == 7) {
      point_type * p = util_malloc( sizeof * p );
      p->x = x;
      p->y = y;
      p->z = z;

      p->i = i-1;
      p->j = j-1;
      p->k = k-1;
      p->skip = skip;
      p->g = ecl_grid_get_global_index3(grid,    p->i, p->j, p->k);
      vector_append_owned_ref( expected, p , free );
    } else
      break;
  }

  fclose( stream );
  test_assert_int_equal( 10 , vector_get_size( expected ));
  return expected;
}
コード例 #6
0
ファイル: ecl_fault_block_layer.c プロジェクト: agchitu/ert
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 );
}
コード例 #7
0
bool fault_block_layer_export( const fault_block_layer_type * layer , ecl_kw_type * faultblock_kw) {
  if (ecl_type_is_int(ecl_kw_get_data_type( faultblock_kw )) && (ecl_kw_get_size( faultblock_kw ) == ecl_grid_get_global_size( layer->grid ))) {
    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 cell_value = layer_iget_cell_value( layer->layer , i , j );
        ecl_kw_iset_int( faultblock_kw , g , cell_value);
      }
    }
    return true;
  } else
    return false;
}
コード例 #8
0
ファイル: ecl_box.cpp プロジェクト: OPM/ResInsight
 ecl_box::ecl_box(const ecl_grid_type * grid, int i1, int i2, int j1, int j2, int k1, int k2) :
   grid(grid),
   i1(std::min(i1,i2)),
   i2(std::max(i1,i2)),
   j1(std::min(j1,j2)),
   j2(std::max(j1,j2)),
   k1(std::min(k1,k2)),
   k2(std::max(k1,k2))
 {
   for (int k=this->k1; k <= this->k2; k++)
     for (int j=this->j1; j <= this->j2; j++)
       for (int i=this->i1; i <= this->i2; i++) {
         int active_index = ecl_grid_get_active_index3(this->grid, i, j , k);
         if (active_index >= 0)
           this->active_index_list.push_back(active_index);
         this->global_index_list.push_back(ecl_grid_get_global_index3(this->grid, i, j, k));
       }
 }
コード例 #9
0
ファイル: field_config.c プロジェクト: bramirex/ert
inline int field_config_global_index(const field_config_type * config, int i, int j, int k) {
    return ecl_grid_get_global_index3( config->grid , i,j,k);
}
コード例 #10
0
ファイル: ecl_grid_DEPTHZ.c プロジェクト: Ensembles/ert
void test_create() {
  ecl_grid_type * ecl_grid;
  int nx = 100;
  int ny = 100;
  int nz = 10;

  double * DXV = util_malloc( nx * sizeof * DXV );
  double * DYV = util_malloc( ny * sizeof * DYV );
  double * DZV = util_malloc( nz * sizeof * DZV );
  double * DEPTHZ = util_malloc( (nx + 1) * (ny + 1) * sizeof * DEPTHZ);

  for (int i=0; i < nx; i++)
    DXV[i] = 1.0 / nx;

  for (int j=0; j < ny; j++)
    DYV[j] = 1.0 / ny;

  for (int k=0; k < nz; k++)
    DZV[k] = 3.0 / nz;
  

  for (int j=0; j <= ny; j++) {
    double y = center_sum(DYV , j);
    for (int i=0; i <= nx; i++) {
      double x = center_sum(DXV , i);
      
      DEPTHZ[i + j*(nx + 1)] = zfunc( x,y );
    }
  }

  ecl_grid = ecl_grid_alloc_dxv_dyv_dzv_depthz( nx,ny,nz,DXV , DYV , DZV , DEPTHZ , NULL);
  
  for (int k=0; k < nz; k++) {
    double z0 = center_sum(DZV , k ) - 0.5*DZV[0];
    for (int j=0; j < ny; j++) {
      double y0 = center_sum(DYV , j );
      for (int i=0; i < nx; i++) {
        double x0 = center_sum(DXV , i );
        double xc,yc,zc;
        int g = ecl_grid_get_global_index3( ecl_grid , i , j , k );
        
        ecl_grid_get_xyz1( ecl_grid , g , &xc , &yc , &zc); 
        test_assert_double_equal( x0 , xc );
        test_assert_double_equal( y0 , yc );

        ecl_grid_get_cell_corner_xyz1( ecl_grid , g , 0 , &xc , &yc , &zc);
        test_assert_double_equal( z0 + zfunc(x0 , y0) , zc );

        ecl_grid_get_cell_corner_xyz1( ecl_grid , g , 4, &xc , &yc , &zc);
        test_assert_double_equal( z0 + zfunc(x0 , y0) + DZV[k] , zc );
      }
    }
  }


  free( DXV );
  free( DYV );
  free( DZV );
  free( DEPTHZ );
  ecl_grid_free( ecl_grid );
}