static void ecl_grid_dims_read_GRID( ecl_grid_dims_type * grid_dims , fortio_type * grid_fortio , fortio_type * data_fortio ) { while (ecl_kw_fseek_kw( DIMENS_KW , false , false , grid_fortio)) { grid_dims_type * dims; { ecl_kw_type * dimens_kw = ecl_kw_fread_alloc( grid_fortio ); int nx = ecl_kw_iget_int( dimens_kw , DIMENS_NX_INDEX ); int ny = ecl_kw_iget_int( dimens_kw , DIMENS_NY_INDEX ); int nz = ecl_kw_iget_int( dimens_kw , DIMENS_NZ_INDEX ); dims = grid_dims_alloc( nx , ny , nz , 0 ); ecl_kw_free( dimens_kw ); } if (data_fortio) { if (ecl_kw_fseek_kw( INTEHEAD_KW , false , false , data_fortio )) { ecl_kw_type * intehead_kw = ecl_kw_fread_alloc( data_fortio ); dims->nactive = ecl_kw_iget_int( intehead_kw , INTEHEAD_NACTIVE_INDEX ); ecl_kw_free( intehead_kw ); } } vector_append_owned_ref( grid_dims->dims_list , dims, grid_dims_free__ ); } }
void ecl_init_file_fwrite_header( fortio_type * fortio , const ecl_grid_type * ecl_grid , const ecl_kw_type * poro , int phases , time_t start_date) { int simulator = INTEHEAD_ECLIPSE100_VALUE; { ecl_kw_type * intehead_kw = ecl_init_file_alloc_INTEHEAD( ecl_grid , phases , start_date , simulator ); ecl_kw_fwrite( intehead_kw , fortio ); ecl_kw_free( intehead_kw ); } { ecl_kw_type * logihead_kw = ecl_init_file_alloc_LOGIHEAD( simulator ); ecl_kw_fwrite( logihead_kw , fortio ); ecl_kw_free( logihead_kw ); } { ecl_kw_type * doubhead_kw = ecl_init_file_alloc_DOUBHEAD( ); ecl_kw_fwrite( doubhead_kw , fortio ); ecl_kw_free( doubhead_kw ); } if (poro) { int poro_size = ecl_kw_get_size( poro ); if ((poro_size == ecl_grid_get_nactive( ecl_grid )) || (poro_size == ecl_grid_get_global_size(ecl_grid))) ecl_init_file_fwrite_poro( fortio , ecl_grid , poro ); else util_abort("%s: keyword PORO has wrong size:%d Grid: %d/%d \n",__func__ , ecl_kw_get_size( poro ) , ecl_grid_get_nactive( ecl_grid ) , ecl_grid_get_global_size( ecl_grid )); } }
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_fread_alloc() { test_work_area_type * work_area = test_work_area_alloc("ecl_kw_fread" ); { ecl_kw_type * kw1 = ecl_kw_alloc( "INT" , 100 , ECL_INT ); int i; for (i=0; i < 100; i++) ecl_kw_iset_int( kw1 , i , i ); { fortio_type * fortio = fortio_open_writer("INT" , false , true ); ecl_kw_fwrite( kw1 , fortio ); fortio_fclose( fortio ); } { fortio_type * fortio = fortio_open_reader("INT" , false , true ); ecl_kw_type * kw2 = ecl_kw_fread_alloc( fortio ); test_assert_true( ecl_kw_is_instance( kw2 )); test_assert_true( ecl_kw_equal( kw1 , kw2 )); ecl_kw_free( kw2 ); fortio_fclose( fortio ); } { offset_type file_size = util_file_size("INT"); test_truncated("INT" , file_size - 4 ); test_truncated("INT" , file_size - 25 ); test_truncated("INT" , 5 ); test_truncated("INT" , 0 ); } ecl_kw_free( kw1 ); } test_work_area_free( work_area ); }
void test_write_header() { int nx = 10; int ny = 10; int nz = 5; int_vector_type * actnum = int_vector_alloc( nx*ny*nz , 1 ); test_work_area_type * test_area = test_work_area_alloc( "ecl_init_file" ); time_t start_time = util_make_date(15 , 12 , 2010 ); ecl_grid_type * ecl_grid; int_vector_iset( actnum , 10 , 0 ); int_vector_iset( actnum , 100 , 0 ); ecl_grid = ecl_grid_alloc_rectangular(nx, ny, nz, 1, 1, 1, int_vector_get_ptr( actnum )); // Write poro with global size. { fortio_type * f = fortio_open_writer( "FOO1.INIT" , false , ECL_ENDIAN_FLIP ); ecl_kw_type * poro = ecl_kw_alloc( "PORO" , ecl_grid_get_global_size( ecl_grid ) , ECL_FLOAT_TYPE ); ecl_kw_scalar_set_float( poro , 0.10 ); ecl_init_file_fwrite_header( f , ecl_grid , poro , 7 , start_time ); ecl_kw_free( poro ); fortio_fclose( f ); } // Write poro with nactive size. { fortio_type * f = fortio_open_writer( "FOO2.INIT" , false , ECL_ENDIAN_FLIP ); ecl_kw_type * poro = ecl_kw_alloc( "PORO" , ecl_grid_get_global_size( ecl_grid ) , ECL_FLOAT_TYPE ); ecl_kw_scalar_set_float( poro , 0.10 ); ecl_init_file_fwrite_header( f , ecl_grid , poro , 7 , start_time ); ecl_kw_free( poro ); fortio_fclose( f ); } { ecl_file_type * file1 = ecl_file_open( "FOO1.INIT" , 0 ); ecl_file_type * file2 = ecl_file_open( "FOO2.INIT" , 0 ); test_assert_true( ecl_kw_equal( ecl_file_iget_named_kw( file1 , "PORV" , 0 ) , ecl_file_iget_named_kw( file2 , "PORV" , 0))); ecl_file_close( file2 ); ecl_file_close( file1 ); } // Poro == NULL { fortio_type * f = fortio_open_writer( "FOO3.INIT" , false , ECL_ENDIAN_FLIP ); ecl_init_file_fwrite_header( f , ecl_grid , NULL , 7 , start_time ); fortio_fclose( f ); } test_work_area_free( test_area ); }
void test_create_invalid( const ecl_grid_type * grid ) { ecl_kw_type * fault_blk_kw = ecl_kw_alloc("FAULTBLK" , ecl_grid_get_global_size( grid ) - 1, ECL_INT_TYPE ); test_assert_NULL( fault_block_layer_alloc( grid , 7 )); ecl_kw_free( fault_blk_kw ); }
void ecl_file_kw_end_transaction(ecl_file_kw_type * file_kw, int ref_count) { if (ref_count == 0 && file_kw->ref_count > 0) { ecl_kw_free(file_kw->kw); file_kw->kw = NULL; } file_kw->ref_count = ref_count; }
static void ecl_file_kw_drop_kw( ecl_file_kw_type * file_kw , inv_map_type * inv_map ) { if (file_kw->kw != NULL) { inv_map_drop_kw( inv_map , file_kw->kw ); ecl_kw_free( file_kw->kw ); file_kw->kw = NULL; } }
void test_create_simple() { test_work_area_type * work_area = test_work_area_alloc("nnc-INIT"); { int nx = 10; int ny = 10; int nz = 10; ecl_grid_type * grid0 = ecl_grid_alloc_rectangular(nx,ny,nz,1,1,1,NULL); ecl_grid_add_self_nnc(grid0, 0 ,nx*ny + 0, 0 ); ecl_grid_add_self_nnc(grid0, 1 ,nx*ny + 1, 1 ); ecl_grid_add_self_nnc(grid0, 2 ,nx*ny + 2, 2 ); { ecl_nnc_geometry_type * nnc_geo = ecl_nnc_geometry_alloc( grid0 ); test_assert_int_equal( ecl_nnc_geometry_size( nnc_geo ) , 3 ); /* Create a dummy INIT file which *ony* contains a TRANNC keyword with the correct size. */ { ecl_kw_type * trann_nnc = ecl_kw_alloc(TRANNNC_KW , ecl_nnc_geometry_size( nnc_geo ), ECL_FLOAT); fortio_type * f = fortio_open_writer( "TEST.INIT" , false, ECL_ENDIAN_FLIP ); for (int i=0; i < ecl_kw_get_size( trann_nnc); i++) ecl_kw_iset_float( trann_nnc , i , i*1.0 ); ecl_kw_fwrite( trann_nnc , f ); fortio_fclose( f ); ecl_kw_free( trann_nnc ); } } ecl_grid_free( grid0 ); } test_work_area_free( work_area ); }
int main(int argc , char ** argv) { int i; ecl_kw_type * ecl_kw = ecl_kw_alloc("HEAD" , 10 , ECL_INT_TYPE); for (i=0; i < 10; i++) ecl_kw_iset_int(ecl_kw , i , i ); { test_work_area_type * work_area = test_work_area_alloc("ecl_kw_grdecl" , true); FILE * stream = util_fopen( "FILE.grdecl" , "w"); ecl_kw_fprintf_grdecl(ecl_kw , stream ); fclose(stream); stream = util_fopen( "FILE.grdecl" , "r"); { ecl_kw_type * ecl_kw2 = ecl_kw_fscanf_alloc_grdecl( stream , "HEAD" , 10 , ECL_INT_TYPE); test_assert_not_NULL( ecl_kw2 ); test_assert_true( ecl_kw_equal( ecl_kw , ecl_kw2)); ecl_kw_free( ecl_kw2 ); } fclose( stream ); stream = util_fopen( "FILE.grdecl" , "w"); ecl_kw_fprintf_grdecl__(ecl_kw , "HEAD1234" , stream ); fclose( stream ); stream = util_fopen( "FILE.grdecl" , "r"); { ecl_kw_type * ecl_kw2 = ecl_kw_fscanf_alloc_grdecl( stream , "HEAD" , 10 , ECL_INT_TYPE); test_assert_NULL( ecl_kw2 ); ecl_kw2 = ecl_kw_fscanf_alloc_grdecl( stream , "HEAD1234" , 10 , ECL_INT_TYPE); test_assert_not_NULL( ecl_kw2 ); test_assert_string_equal( ecl_kw_get_header( ecl_kw2 ) , "HEAD1234" ); test_assert_true( ecl_kw_content_equal( ecl_kw , ecl_kw2 )); ecl_kw_free( ecl_kw2 ); } fclose( stream ); test_work_area_free( work_area ); } ecl_kw_free( ecl_kw ); exit(0); }
int test_grdecl_loader() { FILE * stream = util_fopen("/private/joaho/ERT/NR/python/ctypes/test/data/eclipse/case/PERMX.grdecl" , "r"); ecl_kw_type * kw = ecl_kw_fscanf_alloc_grdecl_dynamic( stream , "PERMX" , ECL_FLOAT_TYPE ); ecl_kw_free( kw ); fclose( stream ); return 1; }
bool check_original_exported_data_equal(const enkf_node_type * field_node) { FILE * original_stream = util_fopen( "petro.grdecl" , "r"); ecl_kw_type * kw_original = ecl_kw_fscanf_alloc_grdecl_dynamic( original_stream , "PORO" , ECL_DOUBLE_TYPE ); enkf_node_ecl_write(field_node, "tmp", NULL, 0); FILE * exported_stream = util_fopen( "tmp/PORO.grdecl" , "r"); ecl_kw_type * kw_exported = ecl_kw_fscanf_alloc_grdecl_dynamic( exported_stream , "PORO" , ECL_DOUBLE_TYPE ); bool ret = ecl_kw_numeric_equal(kw_original, kw_exported, 1e-5); util_fclose(original_stream); util_fclose(exported_stream); ecl_kw_free(kw_original); ecl_kw_free(kw_exported); return ret; }
void test_kw_io_charlength() { test_work_area_type * work_area = test_work_area_alloc("ecl_kw_io_charlength"); { const char * KW0 = "QWERTYUI"; const char * KW1 = "ABCDEFGHIJTTTTTTTTTTTTTTTTTTTTTTABCDEFGHIJKLMNOP"; ecl_kw_type * ecl_kw_out0 = ecl_kw_alloc(KW0 , 5, ECL_FLOAT); ecl_kw_type * ecl_kw_out1 = ecl_kw_alloc(KW1 , 5, ECL_FLOAT); for (int i=0; i < ecl_kw_get_size( ecl_kw_out1); i++) { ecl_kw_iset_float( ecl_kw_out0 , i , i*1.5 ); ecl_kw_iset_float( ecl_kw_out1 , i , i*1.5 ); } { fortio_type * f = fortio_open_writer( "TEST1" , false, ECL_ENDIAN_FLIP ); test_assert_true( ecl_kw_fwrite( ecl_kw_out0, f )); test_assert_false(ecl_kw_fwrite( ecl_kw_out1, f )); fortio_fclose( f ); } { test_assert_false( util_file_exists( "TEST1")); } { FILE * file = util_fopen("TEST2", "w"); ecl_kw_fprintf_grdecl(ecl_kw_out1 , file); fclose(file); } { FILE * file = util_fopen("TEST2", "r"); ecl_kw_type * ecl_kw_in = ecl_kw_fscanf_alloc_grdecl( file , KW1 , -1 , ECL_FLOAT); test_assert_string_equal(KW1, ecl_kw_get_header(ecl_kw_in) ); test_assert_int_equal(5, ecl_kw_get_size( ecl_kw_in) ); test_assert_double_equal(ecl_kw_iget_as_double(ecl_kw_in, 0), 0.0); test_assert_double_equal(ecl_kw_iget_as_double(ecl_kw_in, 4), 6.0); fclose(file); } ecl_kw_free( ecl_kw_out0 ); ecl_kw_free( ecl_kw_out1 ); } test_work_area_free( work_area ); }
void ecl_file_kw_free( ecl_file_kw_type * file_kw ) { if (file_kw->kw != NULL) { ecl_kw_free( file_kw->kw ); file_kw->kw = NULL; } free( file_kw->header ); free( file_kw ); }
void test_float() { size_t N = 1000; int i; ecl_kw_type * kw = ecl_kw_alloc("KW" , N , ECL_FLOAT_TYPE); for (i=0; i < N; i++) test_assert_int_equal( 0 , ecl_kw_iget_float( kw , i )); ecl_kw_free( kw ); }
void test_double() { size_t N = 1000; double i; ecl_kw_type * kw = ecl_kw_alloc("KW" , N , ECL_DOUBLE_TYPE); for (i=0; i < N; i++) test_assert_double_equal( 0 , ecl_kw_iget_double( kw , i )); ecl_kw_free( kw ); }
int main(int argc , char ** argv) { FILE * stream = util_fopen( argv[1] , "r"); ecl_kw_type * gridhead_kw = ecl_kw_fscanf_alloc_grdecl_dynamic__( stream , SPECGRID_KW , false , ECL_INT_TYPE ); ecl_kw_type * zcorn_kw = ecl_kw_fscanf_alloc_grdecl_dynamic( stream , ZCORN_KW , ECL_FLOAT_TYPE ); ecl_kw_type * coord_kw = ecl_kw_fscanf_alloc_grdecl_dynamic( stream , COORD_KW , ECL_FLOAT_TYPE ); ecl_kw_type * actnum_kw = ecl_kw_fscanf_alloc_grdecl_dynamic( stream , ACTNUM_KW , ECL_INT_TYPE ); { int nx = ecl_kw_iget_int( gridhead_kw , SPECGRID_NX_INDEX ); int ny = ecl_kw_iget_int( gridhead_kw , SPECGRID_NY_INDEX ); int nz = ecl_kw_iget_int( gridhead_kw , SPECGRID_NZ_INDEX ); ecl_grid_type * ecl_grid = ecl_grid_alloc_GRDECL_kw( nx , ny , nz, zcorn_kw, coord_kw , actnum_kw , NULL ); /* .... */ ecl_grid_free( ecl_grid ); } ecl_kw_free( gridhead_kw ); ecl_kw_free( zcorn_kw ); ecl_kw_free( actnum_kw ); ecl_kw_free( coord_kw ); fclose( stream ); }
void ecl_file_kw_replace_kw( ecl_file_kw_type * file_kw , fortio_type * target , ecl_kw_type * new_kw ) { if ((file_kw->ecl_type == ecl_kw_get_type( new_kw )) && (file_kw->kw_size == ecl_kw_get_size( new_kw ))) { if (file_kw->kw != NULL) ecl_kw_free( file_kw->kw ); file_kw->kw = new_kw; fortio_fseek( target , file_kw->file_offset , SEEK_SET ); ecl_kw_fwrite( file_kw->kw , target ); } else util_abort("%s: sorry size/type mismatch between in-file keyword and new keyword \n",__func__); }
int main(int argc , char ** argv) { ecl_grid_type * ecl_grid = ecl_grid_alloc_rectangular( 9 , 9 , 2 , 1 , 1 , 1 , NULL ); ecl_kw_type * fault_blk_kw = ecl_kw_alloc("FAULTBLK" , ecl_grid_get_global_size( ecl_grid ) , ECL_INT_TYPE ); test_create( ecl_grid , fault_blk_kw ); test_create_invalid( ecl_grid ); test_trace_edge( ecl_grid ); test_export(ecl_grid); test_neighbours( ecl_grid ); ecl_grid_free( ecl_grid ); ecl_kw_free( fault_blk_kw ); exit(0); }
void ecl_sum_tstep_fwrite( const ecl_sum_tstep_type * ministep , const int_vector_type * index_map , fortio_type * fortio) { { ecl_kw_type * ministep_kw = ecl_kw_alloc( MINISTEP_KW , 1 , ECL_INT_TYPE ); ecl_kw_iset_int( ministep_kw , 0 , ministep->ministep ); ecl_kw_fwrite( ministep_kw , fortio ); ecl_kw_free( ministep_kw ); } { int compact_size = int_vector_size( index_map ); ecl_kw_type * params_kw = ecl_kw_alloc( PARAMS_KW , compact_size , ECL_FLOAT_TYPE ); const int * index = int_vector_get_ptr( index_map ); float * data = ecl_kw_get_ptr( params_kw ); { int i; for (i=0; i < compact_size; i++) data[i] = ministep->data[ index[i] ]; } ecl_kw_fwrite( params_kw , fortio ); ecl_kw_free( params_kw ); } }
void kw_list(const char *filename) { fortio_type *fortio; bool fmt_file = ecl_util_fmt_file(filename); ecl_kw_type * ecl_kw = ecl_kw_alloc_empty(); printf("-----------------------------------------------------------------\n"); printf("%s: \n",filename); fortio = fortio_open_reader(filename , fmt_file , ECL_ENDIAN_FLIP); while( ecl_kw_fread_realloc(ecl_kw , fortio) ) ecl_kw_summarize(ecl_kw); printf("-----------------------------------------------------------------\n"); ecl_kw_free(ecl_kw); fortio_fclose(fortio); }
void ecl_file_kw_replace_kw( ecl_file_kw_type * file_kw , fortio_type * target , ecl_kw_type * new_kw ) { if (!ecl_type_is_equal( ecl_file_kw_get_data_type(file_kw), ecl_kw_get_data_type(new_kw) )) util_abort("%s: sorry type mismatch between in-file keyword and new keyword \n",__func__); if(file_kw->kw_size != ecl_kw_get_size(new_kw)) util_abort("%s: sorry size mismatch between in-file keyword and new keyword \n",__func__); if (file_kw->kw != NULL) ecl_kw_free( file_kw->kw ); file_kw->kw = new_kw; fortio_fseek( target , file_kw->file_offset , SEEK_SET ); ecl_kw_fwrite( file_kw->kw , target ); }
int main(int argc , char ** argv) { const char * grid_file = argv[1]; const char * fault_blk_file = argv[2]; ecl_grid_type * ecl_grid = ecl_grid_alloc( grid_file ); ecl_kw_type * fault_blk_kw; { FILE * stream = util_fopen( fault_blk_file , "r"); fault_blk_kw = ecl_kw_fscanf_alloc_grdecl( stream , "FAULTBLK" , ecl_grid_get_global_size( ecl_grid ) , ECL_INT); fclose( stream ); } test_create( ecl_grid , fault_blk_kw ); ecl_grid_free( ecl_grid ); ecl_kw_free( fault_blk_kw ); exit(0); }
static void ecl_sum_data_fwrite_report__( const ecl_sum_data_type * data , int report_step , fortio_type * fortio) { { ecl_kw_type * seqhdr_kw = ecl_kw_alloc( SEQHDR_KW , SEQHDR_SIZE , ECL_INT_TYPE ); ecl_kw_iset_int( seqhdr_kw , 0 , 0 ); ecl_kw_fwrite( seqhdr_kw , fortio ); ecl_kw_free( seqhdr_kw ); } { int index , index1 , index2; ecl_sum_data_report2internal_range( data , report_step , &index1 , &index2); for (index = index1; index <= index2; index++) { const ecl_sum_tstep_type * tstep = ecl_sum_data_iget_ministep( data , index ); ecl_sum_tstep_fwrite( tstep , ecl_smspec_get_index_map( data->smspec ) , fortio ); } } }
//-------------------------------------------------------------------------------------------------- /// Read known properties from the input file //-------------------------------------------------------------------------------------------------- std::map<QString, QString> RifEclipseInputFileTools::readProperties(const QString& fileName, RigEclipseCaseData* caseData) { CVF_ASSERT(caseData); caf::ProgressInfo mainProgress(2, "Reading Eclipse Input properties"); std::vector<RifKeywordAndFilePos> fileKeywords; RifEclipseInputFileTools::findKeywordsOnFile(fileName, &fileKeywords); mainProgress.setProgress(1); caf::ProgressInfo progress(fileKeywords.size(), "Reading properties"); FILE* gridFilePointer = util_fopen(fileName.toLatin1().data(), "r"); if (!gridFilePointer || !fileKeywords.size() ) { return std::map<QString, QString>(); } std::map<QString, QString> newResults; for (size_t i = 0; i < fileKeywords.size(); ++i) { if (!isValidDataKeyword(fileKeywords[i].keyword)) continue; fseek(gridFilePointer, fileKeywords[i].filePos, SEEK_SET); ecl_kw_type* eclipseKeywordData = ecl_kw_fscanf_alloc_current_grdecl__(gridFilePointer, false, ecl_type_create_from_type(ECL_FLOAT_TYPE)); if (eclipseKeywordData) { QString newResultName = caseData->results(RiaDefines::MATRIX_MODEL)->makeResultNameUnique(fileKeywords[i].keyword); if (readDataFromKeyword(eclipseKeywordData, caseData, newResultName)) { newResults[newResultName] = fileKeywords[i].keyword; } ecl_kw_free(eclipseKeywordData); } progress.setProgress(i); } util_fclose(gridFilePointer); return newResults; }
void checkEgridFile() { size_t numCells = ourFineGridManagerPtr->c_grid()->number_of_cells; // use ERT directly to inspect the EGRID file produced by EclipseWriter auto egridFile = fortio_open_reader("FOO.EGRID", /*isFormated=*/0, ECL_ENDIAN_FLIP); auto eclGrid = eclipseState->getEclipseGrid(); ecl_kw_type *eclKeyword; // yes, that's an assignment! while ((eclKeyword = ecl_kw_fread_alloc(egridFile))) { std::string keywordName(ecl_kw_get_header(eclKeyword)); if (keywordName == "COORD") { std::vector<double> sourceData, resultData; eclGrid->exportCOORD(sourceData); getErtData(eclKeyword, resultData); compareErtData(sourceData, resultData, /*percentTolerance=*/1e-6); } else if (keywordName == "ZCORN") { std::vector<double> sourceData, resultData; eclGrid->exportZCORN(sourceData); getErtData(eclKeyword, resultData); compareErtData(sourceData, resultData, /*percentTolerance=*/1e-6); } else if (keywordName == "ACTNUM") { std::vector<int> sourceData, resultData; eclGrid->exportACTNUM(sourceData); getErtData(eclKeyword, resultData); if (resultData.size() == numCells && sourceData.size() == 0) { sourceData.resize(numCells); std::fill(sourceData.begin(), sourceData.end(), 1); } compareErtData(sourceData, resultData); } ecl_kw_free(eclKeyword); } fortio_fclose(egridFile); }
static void ecl_init_file_fwrite_poro( fortio_type * fortio , const ecl_grid_type * ecl_grid , const ecl_kw_type * poro ) { { ecl_kw_type * porv = ecl_kw_alloc( PORV_KW , ecl_grid_get_global_size( ecl_grid ) , ECL_FLOAT_TYPE); int global_index; bool global_poro = (ecl_kw_get_size( poro ) == ecl_grid_get_global_size( ecl_grid )) ? true : false; for ( global_index = 0; global_index < ecl_grid_get_global_size( ecl_grid ); global_index++) { int active_index = ecl_grid_get_active_index1( ecl_grid , global_index ); if (active_index >= 0) { int poro_index = global_poro ? global_index : active_index; ecl_kw_iset_float( porv , global_index , ecl_kw_iget_float( poro , poro_index ) * ecl_grid_get_cell_volume1( ecl_grid , global_index )); } else ecl_kw_iset_float( porv , global_index , 0 ); } ecl_kw_fwrite( porv , fortio ); ecl_kw_free( porv ); } ecl_kw_fwrite( poro , fortio ); }
int main(int argc, char ** argv) { if (argc < 4) { fprintf(stderr,"%s src_file target_file kw1 kw2 kw3 \n",argv[0]); exit(0); } { const char * src_file = argv[1]; const char * target_file = argv[2]; const char ** kw_list = (const char **) &argv[3]; int num_kw = argc - 3; fortio_type * fortio_src; fortio_type * fortio_target; bool fmt_src , fmt_target; set_type * kw_set = set_alloc( num_kw , kw_list ); if (!ecl_util_fmt_file(src_file, &fmt_src)) util_exit("Hmm - could not determine formatted/unformatted status for:%s \n",src_file); fmt_target = fmt_src; /* Can in principle be different */ fortio_src = fortio_open_reader(src_file , fmt_src , ECL_ENDIAN_FLIP); fortio_target = fortio_open_writer(target_file , fmt_target , ECL_ENDIAN_FLIP); { ecl_kw_type * ecl_kw = ecl_kw_alloc_empty(); while (true) { if (ecl_kw_fread_header( ecl_kw , fortio_src )) { const char * header = ecl_kw_get_header( ecl_kw ); if (set_has_key( kw_set , header )) { ecl_kw_fread_realloc_data(ecl_kw , fortio_src ); ecl_kw_fwrite( ecl_kw , fortio_target ); } else ecl_kw_fskip_data( ecl_kw , fortio_src ); } else break; /* We have reached EOF */ } ecl_kw_free( ecl_kw ); } fortio_fclose(fortio_src); fortio_fclose(fortio_target); set_free( kw_set ); } }
//-------------------------------------------------------------------------------------------------- /// Reads the property data requested into the \a reservoir, overwriting any previous /// properties with the same name. //-------------------------------------------------------------------------------------------------- bool RifEclipseInputFileTools::readProperty(const QString& fileName, RigEclipseCaseData* caseData, const QString& eclipseKeyWord, const QString& resultName) { CVF_ASSERT(caseData); if (!isValidDataKeyword(eclipseKeyWord)) return false; FILE* filePointer = util_fopen(fileName.toLatin1().data(), "r"); if (!filePointer) return false; ecl_kw_type* eclipseKeywordData = ecl_kw_fscanf_alloc_grdecl_dynamic__(filePointer, eclipseKeyWord.toLatin1().data(), false, ecl_type_create_from_type(ECL_FLOAT_TYPE)); bool isOk = false; if (eclipseKeywordData) { isOk = readDataFromKeyword(eclipseKeywordData, caseData, resultName); ecl_kw_free(eclipseKeywordData); } util_fclose(filePointer); return isOk; }
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 ); }