static void ecl_sum_fread_data( ecl_sum_type * ecl_sum , const stringlist_type * data_files , bool include_restart) { if (ecl_sum->data != NULL) ecl_sum_free_data( ecl_sum ); ecl_sum->data = ecl_sum_data_alloc( ecl_sum->smspec ); ecl_sum_data_fread( ecl_sum->data , data_files ); if (include_restart) { const char * path = ecl_sum->path; const stringlist_type * restart_cases = ecl_smspec_get_restart_list( ecl_sum->smspec ); stringlist_type * restart_files = stringlist_alloc_new(); int restart_nr; for (restart_nr = 0; restart_nr < stringlist_get_size( restart_cases ); restart_nr++) { ecl_util_alloc_summary_data_files(path , stringlist_iget( restart_cases , restart_nr ) , ecl_sum->fmt_case , restart_files ); ecl_sum_data_fread_restart( ecl_sum->data , restart_files ); } stringlist_free( restart_files ); } }
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; }