Example #1
0
void test_rft_read_write(const char * rft_file){
    ecl_rft_file_type * rft = ecl_rft_file_alloc( rft_file );
    ecl_rft_node_type  ** nodes =(ecl_rft_node_type  **) malloc(sizeof(ecl_rft_node_type *) * 3);
    int size = ecl_rft_file_get_size(rft);
    for(int i =0;i<size;i++){
        const ecl_rft_node_type * rft_node = ecl_rft_file_iget_node(rft, i);
        nodes[i] =rft_node;
    }
    ecl_rft_node_type * old_node = ecl_rft_file_iget_node(rft, 0);
    ecl_rft_node_type * new_node = ecl_rft_node_alloc_new("DUMMY", "R", ecl_rft_node_get_date(old_node), ecl_rft_node_get_days(old_node));
    nodes[2]=new_node;
    test_work_area_type * work_area = test_work_area_alloc("RFT_RW");
    
    ecl_rft_file_update("eclipse.rft", nodes,3, ERT_ECL_METRIC_UNITS);
    test_work_area_free(work_area);
    free(nodes);
}
ecl_rft_node_type * ecl_rft_file_get_well_time_rft( const ecl_rft_file_type * rft_file , const char * well , time_t recording_time) {
  int index = ecl_rft_file_get_node_index_time_rft(rft_file, well, recording_time);
  if (index !=-1) {
    return ecl_rft_file_iget_node(rft_file, index);
  } else{
    return NULL;
  }
}
Example #3
0
void test_plt_msw( const char * plt_file ) {
  ecl_rft_file_type * plt = ecl_rft_file_alloc( plt_file );
  ecl_rft_node_type * plt_node = ecl_rft_file_iget_node( plt , 11 );

  test_assert_true( ecl_rft_node_is_PLT( plt_node ));
  test_assert_true( ecl_rft_node_is_MSW( plt_node ));
  test_assert_int_equal( 22 , ecl_rft_node_get_size( plt_node ));
  ecl_rft_node_inplace_sort_cells( plt_node );
  {
    int i;
    for (i=1; i < ecl_rft_node_get_size( plt_node ); i++) {
      const ecl_rft_cell_type * prev_cell = ecl_rft_node_iget_cell( plt_node , i - 1);
      const ecl_rft_cell_type * this_cell = ecl_rft_node_iget_cell( plt_node , i );

      test_assert_true( ecl_rft_cell_get_connection_start( prev_cell ) < ecl_rft_cell_get_connection_start( this_cell ));
      test_assert_true( ecl_rft_cell_get_connection_end( prev_cell ) < ecl_rft_cell_get_connection_end( this_cell ));
    }
  }

  ecl_rft_file_free( plt );
}
static int ecl_rft_file_get_node_index_time_rft( const ecl_rft_file_type * rft_file , const char * well , time_t recording_time) {
  int global_index = -1;
  if (hash_has_key( rft_file->well_index , well)) {
    const int_vector_type * index_vector = hash_get(rft_file->well_index , well);
    int well_index = 0;
    while (true) {
      if (well_index == int_vector_size( index_vector ))
        break;

      {
        const ecl_rft_node_type * node = ecl_rft_file_iget_node( rft_file , int_vector_iget( index_vector , well_index ));
        if (ecl_rft_node_get_date( node ) == recording_time) {
          global_index = int_vector_iget( index_vector , well_index );
          break;
        }
      }

      well_index++;
    }
  }
  return global_index;
}
Example #5
0
// Hardcoded GURBAT values
void test_rft( const char * rft_file ) {
  ecl_rft_file_type * rft = ecl_rft_file_alloc( rft_file );
  ecl_rft_node_type * rft_node = ecl_rft_file_iget_node( rft , 0 );
  
  test_assert_true( ecl_rft_node_is_RFT( rft_node ));
  test_assert_int_equal( 14 , ecl_rft_node_get_size( rft_node ));
  test_assert_false( ecl_rft_node_is_MSW( rft_node ));
  
  test_assert_double_equal( 260.6111   , ecl_rft_node_iget_pressure( rft_node , 0 ));
  test_assert_double_equal( 0.0581993  , ecl_rft_node_iget_soil( rft_node , 0 ));
  test_assert_double_equal( 0.9405648  , ecl_rft_node_iget_swat( rft_node , 0 ));
  test_assert_double_equal( 0.00123579  , ecl_rft_node_iget_sgas( rft_node , 0 ));

  {
    int i,j,k;

    ecl_rft_node_iget_ijk( rft_node , 0 , &i , &j , &k );
    test_assert_int_equal( 32 , i );
    test_assert_int_equal( 53 , j );
    test_assert_int_equal( 0  , k );    

    ecl_rft_node_iget_ijk( rft_node , 13 , &i , &j , &k );
    test_assert_int_equal( 32 , i );
    test_assert_int_equal( 54 , j );
    test_assert_int_equal( 12 , k );    

    for (i=0; i < ecl_rft_node_get_size( rft_node );  i++) {
      const ecl_rft_cell_type * cell1 = ecl_rft_node_iget_cell( rft_node , i );
      const ecl_rft_cell_type * cell2 = ecl_rft_node_iget_cell_sorted( rft_node , i );

      test_assert_ptr_equal( cell1 , cell2 );
    }
  }
  ecl_rft_node_inplace_sort_cells( rft_node );

  ecl_rft_file_free( rft );
}
Example #6
0
// Hardcoded values from a test case with a PLT.
void test_plt( const char * plt_file ) {
  ecl_rft_file_type * plt = ecl_rft_file_alloc( plt_file );
  ecl_rft_node_type * plt_node = ecl_rft_file_iget_node( plt , 11 );

  test_assert_true( ecl_rft_node_is_PLT( plt_node ));
  test_assert_false( ecl_rft_node_is_MSW( plt_node ));
  test_assert_int_equal( 22 , ecl_rft_node_get_size( plt_node ));

  test_assert_double_equal( 244.284  , ecl_rft_node_iget_pressure( plt_node , 0 ));
  test_assert_double_equal( 167.473  , ecl_rft_node_iget_orat( plt_node , 0 ));
  test_assert_double_equal( 41682.2  , ecl_rft_node_iget_grat( plt_node , 0 ));
  test_assert_double_equal( 0.958927 , ecl_rft_node_iget_wrat( plt_node , 0 ));
  
  {
    int i,j,k;

    ecl_rft_node_iget_ijk( plt_node , 0 , &i , &j , &k );
    test_assert_int_equal( 39 , i );
    test_assert_int_equal( 33 , j );
    test_assert_int_equal( 16 , k );    
    
    ecl_rft_node_iget_ijk( plt_node , 21 , &i , &j , &k );
    test_assert_int_equal( 44 , i );
    test_assert_int_equal( 34 , j );
    test_assert_int_equal(  7 , k );    

    for (i=0; i < ecl_rft_node_get_size( plt_node );  i++) {
      const ecl_rft_cell_type * cell1 = ecl_rft_node_iget_cell( plt_node , i );
      const ecl_rft_cell_type * cell2 = ecl_rft_node_iget_cell_sorted( plt_node , i );

      test_assert_ptr_equal( cell1 , cell2 );
    }
    ecl_rft_node_inplace_sort_cells( plt_node );
  }
  
  ecl_rft_file_free( plt );
}
ecl_rft_node_type * ecl_rft_file_iget_well_rft( const ecl_rft_file_type * rft_file , const char * well, int index) {
  const int_vector_type * index_vector = hash_get(rft_file->well_index , well);
  return ecl_rft_file_iget_node( rft_file , int_vector_iget(index_vector , index));
}