bool ecl_util_fmt_file(const char *filename , bool * __fmt_file) { /*const int min_size = 32768;*/ const int min_size = 256; /* Veeeery small */ int report_nr; ecl_file_enum file_type; bool status = true; bool fmt_file; if (util_file_exists(filename)) { file_type = ecl_util_get_file_type(filename , &fmt_file , &report_nr); if (file_type == ECL_OTHER_FILE) { if (util_file_size(filename) > min_size) fmt_file = util_fmt_bit8(filename); else status = false; // Do not know ?? } } else { file_type = ecl_util_get_file_type(filename , &fmt_file , &report_nr); if (file_type == ECL_OTHER_FILE) status = false; // Do not know ?? } *__fmt_file = fmt_file; return status; }
static void ecl_sum_data_fread__( ecl_sum_data_type * data , time_t load_end , const stringlist_type * filelist) { ecl_file_enum file_type; if (stringlist_get_size( filelist ) == 0) util_abort("%s: internal error - function called with empty list of data files.\n",__func__); file_type = ecl_util_get_file_type( stringlist_iget( filelist , 0 ) , NULL , NULL); if ((stringlist_get_size( filelist ) > 1) && (file_type != ECL_SUMMARY_FILE)) util_abort("%s: internal error - when calling with more than one file - you can not supply a unified file - come on?! \n",__func__); { int filenr; if (file_type == ECL_SUMMARY_FILE) { /* Not unified. */ for (filenr = 0; filenr < stringlist_get_size( filelist ); filenr++) { const char * data_file = stringlist_iget( filelist , filenr); ecl_file_enum file_type; int report_step; file_type = ecl_util_get_file_type( data_file , NULL , &report_step); /** ECLIPSE starts a report step by writing an empty summary file, therefor we must verify that the ecl_file instance returned by ecl_file_fread_alloc() is different from NULL before adding it to the ecl_sum_data instance. */ if (file_type != ECL_SUMMARY_FILE) util_abort("%s: file:%s has wrong type \n",__func__ , data_file); { ecl_file_type * ecl_file = ecl_file_open( data_file ); ecl_sum_data_add_ecl_file( data , load_end , report_step , ecl_file , data->smspec); ecl_file_close( ecl_file ); } } } else if (file_type == ECL_UNIFIED_SUMMARY_FILE) { ecl_file_type * ecl_file = ecl_file_open( stringlist_iget(filelist ,0 )); int report_step = 1; /* <- ECLIPSE numbering - starting at 1. */ while (true) { /* Observe that there is a number discrepancy between ECLIPSE and the ecl_file_select_smryblock() function. ECLIPSE starts counting report steps at 1; whereas the first SEQHDR block in the unified summary file is block zero (in ert counting). */ if (ecl_file_select_smryblock( ecl_file , report_step - 1)) { ecl_sum_data_add_ecl_file( data , load_end , report_step , ecl_file , data->smspec); report_step++; } else break; } ecl_file_close( ecl_file ); } else util_abort("%s: invalid file type:%s \n",__func__ , ecl_util_file_type_name(file_type )); } ecl_sum_data_build_index( data ); }
char * ecl_rft_file_alloc_case_filename(const char * case_input ) { ecl_file_enum file_type; bool fmt_file; file_type = ecl_util_get_file_type( case_input , &fmt_file , NULL); if (file_type == ECL_RFT_FILE) return util_alloc_string_copy (case_input ); else { char * return_file = NULL; char * path; char * basename; util_alloc_file_components( case_input , &path , &basename , NULL); if ((file_type == ECL_OTHER_FILE) || (file_type == ECL_DATA_FILE)) { /* Impossible to infer formatted/unformatted from the case_input */ char * RFT_file = ecl_util_alloc_filename( path , basename , ECL_RFT_FILE , false , -1 ); char * FRFT_file = ecl_util_alloc_filename( path , basename , ECL_RFT_FILE , true , -1 ); if (util_file_exists( RFT_file )) return_file = util_alloc_string_copy( RFT_file ); else if (util_file_exists( FRFT_file )) return_file = util_alloc_string_copy( FRFT_file ); free( RFT_file ); free( FRFT_file ); } else { char * RFT_file = ecl_util_alloc_filename( path , basename , ECL_RFT_FILE , fmt_file , -1 ); if (util_file_exists( RFT_file )) return_file = util_alloc_string_copy( RFT_file ); free( RFT_file ); } return return_file; } }
void test_file( const char * filename , int occurence , bool exists , const ecl_rsthead_type * true_header) { int report_step = ecl_util_filename_report_nr( filename ); ecl_file_type * rst_file = ecl_file_open( filename , 0); ecl_file_enum file_type = ecl_util_get_file_type( filename , NULL , NULL ); ecl_file_view_type * rst_view; ecl_rsthead_type * rst_head; if (file_type == ECL_RESTART_FILE) rst_view = ecl_file_get_global_view( rst_file ); else rst_view = ecl_file_get_restart_view( rst_file , occurence , -1 , -1 , -1 ); if (exists) { test_assert_not_NULL( rst_view ); rst_head = ecl_rsthead_alloc( rst_view , report_step); test_assert_not_NULL( rst_head ); if (occurence == 0) { ecl_rsthead_type * rst_head0 = ecl_rsthead_alloc( rst_view , report_step ); test_assert_true( ecl_rsthead_equal( rst_head , rst_head0 )); ecl_rsthead_free( rst_head0 ); } test_assert_true( ecl_rsthead_equal( rst_head , true_header )); ecl_rsthead_free( rst_head ); } else test_assert_NULL( rst_view ); }
bool ecl_util_unified_file(const char *filename) { int report_nr; ecl_file_enum file_type; bool fmt_file; file_type = ecl_util_get_file_type(filename , &fmt_file , &report_nr); if ((file_type == ECL_UNIFIED_RESTART_FILE) || (file_type == ECL_UNIFIED_SUMMARY_FILE)) return true; else return false; }
static void ecl_sum_fread(ecl_sum_type * ecl_sum , const char *header_file , const stringlist_type *data_files , bool include_restart) { ecl_sum->smspec = ecl_smspec_fread_alloc( header_file , ecl_sum->key_join_string , include_restart); { bool fmt_file; ecl_util_get_file_type( header_file , &fmt_file , NULL); ecl_sum_set_fmt_case( ecl_sum , fmt_file ); } ecl_sum_fread_data( ecl_sum , data_files , include_restart ); { ecl_file_enum file_type = ecl_util_get_file_type( stringlist_iget( data_files , 0 ) , NULL , NULL); if (file_type == ECL_SUMMARY_FILE) ecl_sum_set_unified( ecl_sum , false ); else if (file_type == ECL_UNIFIED_SUMMARY_FILE) ecl_sum_set_unified( ecl_sum , true); else util_abort("%s: what the f**k? \n",__func__); } }
void ecl_file_fwrite(const ecl_file_type * ecl_file , const char * filename, bool fmt_file) { bool __fmt_file; ecl_file_enum file_type; file_type = ecl_util_get_file_type( filename , &__fmt_file , NULL); if (file_type == ECL_OTHER_FILE) __fmt_file = fmt_file; { fortio_type * target = fortio_open_writer( filename , __fmt_file , ECL_ENDIAN_FLIP); ecl_file_fwrite_fortio( ecl_file , target , 0); fortio_fclose( target ); } }
ecl_grid_dims_type * ecl_grid_dims_alloc( const char * grid_file , const char * data_file) { ecl_grid_dims_type * grid_dims = NULL; bool grid_fmt_file; ecl_file_enum grid_file_type = ecl_util_get_file_type( grid_file , &grid_fmt_file , NULL ); if ((grid_file_type == ECL_GRID_FILE) || (grid_file_type == ECL_EGRID_FILE)) { fortio_type * grid_fortio = fortio_open_reader( grid_file , grid_fmt_file , ECL_ENDIAN_FLIP ); if (grid_fortio) { grid_dims = util_malloc( sizeof * grid_dims ); grid_dims->dims_list = vector_alloc_new( ); { fortio_type * data_fortio = NULL; bool data_fmt_file; if (data_file) { ecl_util_get_file_type( data_file , &data_fmt_file , NULL ); data_fortio = fortio_open_reader( data_file , data_fmt_file , ECL_ENDIAN_FLIP ); } if (grid_file_type == ECL_EGRID_FILE) ecl_grid_dims_read_EGRID( grid_dims , grid_fortio , data_fortio ); else ecl_grid_dims_read_GRID( grid_dims , grid_fortio , data_fortio ); if (data_fortio) fortio_fclose( data_fortio ); } fortio_fclose( grid_fortio ); } } return grid_dims; }
//-------------------------------------------------------------------------------------------------- /// Get first occurrence of file of given type in given list of filenames, as filename or nullptr if not found //-------------------------------------------------------------------------------------------------- QString RifEclipseOutputFileTools::firstFileNameOfType(const QStringList& fileSet, ecl_file_enum fileType) { int i; for (i = 0; i < fileSet.count(); i++) { bool formatted = false; int reportNumber = -1; if (ecl_util_get_file_type(RiaStringEncodingTools::toNativeEncoded(fileSet.at(i)).data(), &formatted, &reportNumber) == fileType) { return fileSet.at(i); } } return QString::null; }
void well_info_load_rst_eclfile( well_info_type * well_info , ecl_file_type * ecl_file, bool load_segment_information) { int report_nr; const char* filename = ecl_file_get_src_file(ecl_file); ecl_file_enum file_type = ecl_util_get_file_type( filename , NULL , &report_nr); if ((file_type == ECL_RESTART_FILE) || (file_type == ECL_UNIFIED_RESTART_FILE)) { if (file_type == ECL_RESTART_FILE) well_info_add_wells( well_info , ecl_file , report_nr , load_segment_information ); else well_info_add_UNRST_wells( well_info , ecl_file , load_segment_information ); } else util_abort("%s: invalid file type: %s - must be a restart file\n", __func__ , filename); }
ui_return_type * ecl_config_validate_grid( const ecl_config_type * ecl_config , const char * grid_file ) { ui_return_type * ui_return; if (util_file_exists( grid_file )) { ecl_file_enum file_type = ecl_util_get_file_type( grid_file , NULL , NULL ); if ((file_type == ECL_EGRID_FILE) || (file_type == ECL_GRID_FILE)) ui_return = ui_return_alloc( UI_RETURN_OK ); else { ui_return = ui_return_alloc( UI_RETURN_FAIL ); ui_return_add_error( ui_return , "Input argument is not a GRID/EGRID file"); } } else { ui_return = ui_return_alloc( UI_RETURN_FAIL ); ui_return_add_error( ui_return , "Input argument does not exist."); } return ui_return; }
//-------------------------------------------------------------------------------------------------- /// Get all files of the given type from the provided list of filenames //-------------------------------------------------------------------------------------------------- QStringList RifEclipseOutputFileTools::filterFileNamesOfType(const QStringList& fileSet, ecl_file_enum fileType) { QStringList fileNames; int i; for (i = 0; i < fileSet.count(); i++) { bool formatted = false; int reportNumber = -1; if (ecl_util_get_file_type(fileSet.at(i).toAscii().data(), &formatted, &reportNumber) == fileType) { fileNames.append(fileSet.at(i)); } } return fileNames; }
// Inspired by the ecl_pack application in the ERT library void concatenateRestart(const std::string& basename) { std::string inputPath, inputBase; splitBasename(basename, inputPath, inputBase); stringlist_type* inputFiles = stringlist_alloc_new(); const int numFiles = ecl_util_select_filelist(inputPath.c_str(), inputBase.c_str(), ECL_RESTART_FILE, false, inputFiles); const char* target_file_name = ecl_util_alloc_filename(inputPath.c_str(), inputBase.c_str(), ECL_UNIFIED_RESTART_FILE, false, -1); fortio_type* target = fortio_open_writer(target_file_name, false, ECL_ENDIAN_FLIP); int dummy; ecl_kw_type* seqnum_kw = ecl_kw_alloc_new("SEQNUM", 1, ECL_INT, &dummy); int reportStep = 0; for (int i = 0; i < numFiles; ++i) { ecl_util_get_file_type(stringlist_iget(inputFiles, i), nullptr, &reportStep); ecl_file_type* src_file = ecl_file_open(stringlist_iget(inputFiles, i), 0); ecl_kw_iset_int(seqnum_kw, 0, reportStep); ecl_kw_fwrite(seqnum_kw, target); ecl_file_fwrite_fortio(src_file, target, 0); ecl_file_close(src_file); } fortio_fclose(target); stringlist_free(inputFiles); }
int main(int argc, char ** argv) { int num_files = argc - 1; if (num_files >= 1) { /* File type and formatted / unformatted is determined from the first argument on the command line. */ char * ecl_base; char * path; ecl_file_enum file_type , target_type; bool fmt_file; /** Look at the first command line argument to determine type and formatted/unformatted status. */ file_type = ecl_util_get_file_type( argv[1] , &fmt_file , NULL); if (file_type == ECL_SUMMARY_FILE) target_type = ECL_UNIFIED_SUMMARY_FILE; else if (file_type == ECL_RESTART_FILE) target_type = ECL_UNIFIED_RESTART_FILE; else { util_exit("The ecl_pack program can only be used with ECLIPSE restart files or summary files.\n"); target_type = -1; } util_alloc_file_components( argv[1] , &path , &ecl_base , NULL); /** Will pack to cwd, even though the source files might be somewhere else. To unpack to the same directory as the source files, just send in @path as first argument when creating the target_file. */ { msg_type * msg; int i , report_step , prev_report_step; char * target_file_name = ecl_util_alloc_filename( NULL , ecl_base , target_type , fmt_file , -1); stringlist_type * filelist = stringlist_alloc_argv_copy( (const char **) &argv[1] , num_files ); ecl_kw_type * seqnum_kw = NULL; fortio_type * target = fortio_open_writer( target_file_name , fmt_file , ECL_ENDIAN_FLIP); if (target_type == ECL_UNIFIED_RESTART_FILE) { int dummy; seqnum_kw = ecl_kw_alloc_new("SEQNUM" , 1 , ECL_INT_TYPE , &dummy); } { char * msg_format = util_alloc_sprintf("Packing %s <= " , target_file_name); msg = msg_alloc( msg_format , false); free( msg_format ); } msg_show( msg ); stringlist_sort( filelist , ecl_util_fname_report_cmp); prev_report_step = -1; for (i=0; i < num_files; i++) { ecl_file_enum this_file_type; this_file_type = ecl_util_get_file_type( stringlist_iget(filelist , i) , NULL , &report_step); if (this_file_type == file_type) { if (report_step == prev_report_step) util_exit("Tried to write same report step twice: %s / %s \n", stringlist_iget(filelist , i-1) , stringlist_iget(filelist , i)); prev_report_step = report_step; msg_update(msg , stringlist_iget( filelist , i)); { ecl_file_type * src_file = ecl_file_open( stringlist_iget( filelist , i) , 0 ); if (target_type == ECL_UNIFIED_RESTART_FILE) { /* Must insert the SEQNUM keyword first. */ ecl_kw_iset_int(seqnum_kw , 0 , report_step); ecl_kw_fwrite( seqnum_kw , target ); } ecl_file_fwrite_fortio( src_file , target , 0); ecl_file_close( src_file ); } } /* Else skipping file of incorrect type. */ } msg_free(msg , false); fortio_fclose( target ); free(target_file_name); stringlist_free( filelist ); if (seqnum_kw != NULL) ecl_kw_free(seqnum_kw); } free(ecl_base); util_safe_free(path); } }
void unpack_file(const char * filename) { ecl_file_enum target_type = ECL_OTHER_FILE; ecl_file_enum file_type; bool fmt_file; file_type = ecl_util_get_file_type(filename , &fmt_file , NULL); if (file_type == ECL_UNIFIED_SUMMARY_FILE) target_type = ECL_SUMMARY_FILE; else if (file_type == ECL_UNIFIED_RESTART_FILE) target_type = ECL_RESTART_FILE; else util_exit("Can only unpack unified ECLIPSE summary and restart files\n"); if (target_type == ECL_SUMMARY_FILE) { printf("** Warning: when unpacking unified summary files it as ambigous - starting with 0001 -> \n"); } { ecl_file_type * src_file = ecl_file_open( filename , 0 ); int size; int offset; int report_step = 0; int block_index = 0; char * path; char * base; msg_type * msg; util_alloc_file_components( filename , &path , &base , NULL); { char * label = util_alloc_sprintf("Unpacking %s => ", filename); msg = msg_alloc( label , false); free( label ); } msg_show(msg); if (target_type == ECL_SUMMARY_FILE) size = ecl_file_get_num_named_kw( src_file , "SEQHDR" ); else size = ecl_file_get_num_named_kw( src_file , "SEQNUM" ); while (true) { if (block_index == size) break; if (target_type == ECL_SUMMARY_FILE) { ecl_file_select_block( src_file , SEQHDR_KW , block_index ); report_step += 1; offset = 0; } else { ecl_kw_type * seqnum_kw; ecl_file_select_block( src_file , SEQNUM_KW , block_index ); seqnum_kw = ecl_file_iget_named_kw( src_file , SEQNUM_KW , 0); report_step = ecl_kw_iget_int( seqnum_kw , 0); offset = 1; } /** Will unpack to cwd, even though the source files might be somewhere else. To unpack to the same directory as the source files, just send in @path as first argument when creating the target_file. */ { char * target_file = ecl_util_alloc_filename( NULL , base , target_type , fmt_file , report_step); fortio_type * fortio_target = fortio_open_writer( target_file , fmt_file , ECL_ENDIAN_FLIP ); msg_update(msg , target_file); ecl_file_fwrite_fortio( src_file , fortio_target , offset); fortio_fclose(fortio_target); free(target_file); } block_index++; } ecl_file_close( src_file ); util_safe_free(path); free(base); msg_free(msg , true); } }
bool ecl_util_alloc_summary_files(const char * path , const char * _base , const char * ext , char ** _header_file , stringlist_type * filelist) { bool fmt_input = false; bool fmt_set = false; bool fmt_file = true; bool unif_input = false; bool unif_set = false; char * header_file = NULL; char * base; *_header_file = NULL; /* 1: We start by inspecting the input extension and see if we can learn anything about formatted/unformatted and unified/non-unified from this. The input extension can be NULL, in which case we learn nothing. */ if (_base == NULL) base = ecl_util_alloc_base_guess(path); else base = (char *) _base; if (ext != NULL) { ecl_file_enum input_type; { char * test_name = util_alloc_filename( NULL , base, ext ); input_type = ecl_util_get_file_type( test_name , &fmt_input , NULL); free( test_name ); } if ((input_type != ECL_OTHER_FILE) && (input_type != ECL_DATA_FILE)) { /* The file has been recognized as a file type from which we can at least infer formatted/unformatted inforamtion. */ fmt_set = true; switch (input_type) { case(ECL_SUMMARY_FILE): case(ECL_RESTART_FILE): unif_input = false; unif_set = true; break; case(ECL_UNIFIED_SUMMARY_FILE): case(ECL_UNIFIED_RESTART_FILE): unif_input = true; unif_set = true; break; default: /* Nothing wrong with this */ break; } } } /* 2: We continue by looking for header files. */ { char * fsmspec_file = ecl_util_alloc_exfilename(path , base , ECL_SUMMARY_HEADER_FILE , true , -1); char * smspec_file = ecl_util_alloc_exfilename(path , base , ECL_SUMMARY_HEADER_FILE , false , -1); if ((fsmspec_file == NULL) && (smspec_file == NULL)) /* Neither file exists */ return false; if (fmt_set) /* The question of formatted|unformatted has already been settled based on the input filename. */ fmt_file = fmt_input; else { if ((fsmspec_file != NULL) && (smspec_file != NULL)) { /* Both fsmspec and smspec exist - we take the newest. */ if (util_file_difftime(fsmspec_file , smspec_file) < 0) fmt_file = true; else fmt_file = false; } else { /* Only one of fsmspec / smspec exists */ if (fsmspec_file != NULL) fmt_file = true; else fmt_file = false; } } if (fmt_file) { header_file = fsmspec_file; util_safe_free( smspec_file ); } else { header_file = smspec_file; util_safe_free( fsmspec_file ); } if (header_file == NULL) return false; /* If you insist on e.g. unformatted and only fsmspec exists - no results for you. */ } /* 3: OK - we have found a SMSPEC / FMSPEC file - continue to look for XXX.Snnnn / XXX.UNSMRY files. */ if (unif_set) { /* Based on the input file we have inferred whether to look for unified or non-unified input files. */ if ( unif_input ) { char * unif_data_file = ecl_util_alloc_exfilename(path , base , ECL_UNIFIED_SUMMARY_FILE , fmt_file , -1); if (unif_data_file != NULL) { stringlist_append_copy( filelist , unif_data_file ); free( unif_data_file ); } } else ecl_util_select_filelist( path , base , ECL_SUMMARY_FILE , fmt_file , filelist); } else ecl_util_alloc_summary_data_files( path , base , fmt_file , filelist ); if (_base == NULL) free(base); *_header_file = header_file; return (stringlist_get_size(filelist) > 0) ? true : false; }