void test_read_erroneous_gen_kw_file() { const char * parameter_filename = "MULTFLT_with_errors.txt"; const char * tmpl_filename = "MULTFLT.tmpl"; { FILE * stream = util_fopen(parameter_filename, "w"); const char * data = util_alloc_sprintf("MULTFLT1 NORMAL 0\nMULTFLT2 RAW\nMULTFLT3 NORMAL 0"); util_fprintf_string(data, 30, true, stream); util_fclose(stream); FILE * tmpl_stream = util_fopen(tmpl_filename, "w"); const char * tmpl_data = util_alloc_sprintf("<MULTFLT1> <MULTFLT2> <MULTFLT3>\n"); util_fprintf_string(tmpl_data, 30, true, tmpl_stream); util_fclose(tmpl_stream); } gen_kw_config_type * gen_kw_config = gen_kw_config_alloc_empty("MULTFLT", "<%s>"); vector_type * arg = vector_alloc_new(); vector_append_ref( arg , gen_kw_config ); vector_append_ref(arg, parameter_filename); test_assert_util_abort("arg_pack_fscanf", read_erroneous_gen_kw_file, arg); vector_free(arg); gen_kw_config_free(gen_kw_config); }
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; }
static void enkf_main_write_current_case_file( const enkf_main_type * enkf_main, const char * case_path) { const char * ens_path = model_config_get_enspath( enkf_main->model_config); const char * base = CURRENT_CASE_FILE; char * current_case_file = util_alloc_filename(ens_path , base, NULL); FILE * stream = util_fopen( current_case_file , "w"); fprintf(stream, "%s", case_path); util_fclose(stream); free(current_case_file); }
char* enkf_main_read_alloc_current_case_name(const enkf_main_type * enkf_main) { char * current_case = NULL; const char * ens_path = model_config_get_enspath( enkf_main->model_config); char * current_case_file = util_alloc_filename(ens_path, CURRENT_CASE_FILE, NULL); if (enkf_main_current_case_file_exists(enkf_main)) { FILE * stream = util_fopen( current_case_file , "r"); current_case = util_fscanf_alloc_token(stream); util_fclose(stream); } else { util_abort("%s: File: storage/current_case not found, aborting! \n",__func__); } free(current_case_file); return current_case; }
//-------------------------------------------------------------------------------------------------- /// 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; }
bool ranking_table_fwrite_ranking( const ranking_table_type * ranking_table , const char * ranking_key, const char * filename ) { if (hash_has_key( ranking_table->ranking_table , ranking_key)) { void * ranking = hash_get( ranking_table->ranking_table , ranking_key ); FILE * file = util_mkdir_fopen(filename, "w"); if (data_ranking_is_instance( ranking )) { data_ranking_type * data_ranking = data_ranking_safe_cast( ranking ); data_ranking_display( data_ranking , file ); } else if (misfit_ranking_is_instance( ranking )) { misfit_ranking_type * misfit_ranking = misfit_ranking_safe_cast( ranking ); misfit_ranking_display( misfit_ranking , file ); } else util_abort("%s: internal error \n",__func__); util_fclose(file); return true; } else return false; }
//-------------------------------------------------------------------------------------------------- /// 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 check_exported_data(const char * exported_file, const char * init_file, field_file_format_type file_type, const field_config_type * field_config, const field_type * field, int nx, int ny, int nz) { FILE * original_stream = NULL; ecl_kw_type * kw_original = NULL; FILE * exported_stream = NULL; ecl_kw_type * kw_exported = NULL; field_type * exported_field = NULL; field_config_type * exported_field_config = NULL; { if (init_file) { original_stream = util_fopen( init_file , "r"); kw_original = ecl_kw_fscanf_alloc_grdecl_dynamic( original_stream , field_config_get_key(field_config) , ECL_DOUBLE_TYPE ); } if (ECL_GRDECL_FILE == file_type) { exported_stream = util_fopen( exported_file , "r"); kw_exported = ecl_kw_fscanf_alloc_grdecl_dynamic( exported_stream , field_config_get_key(field_config) , ECL_DOUBLE_TYPE ); } else if (RMS_ROFF_FILE == file_type) { ecl_grid_type * grid = field_config_get_grid(field_config); exported_field_config = field_config_alloc_empty(field_config_get_key(field_config), grid, NULL, true); exported_field = field_alloc(exported_field_config); bool keep_inactive = true; field_fload_rms(exported_field, exported_file, keep_inactive); } } { int k, j, i = 0; for (k=0; k < nz; k++) { for (j=0; j < ny; j++) { for (i=0; i < nx; i++) { bool active = field_config_active_cell(field_config, i, j, k); double field_value = active ? field_ijk_get_double(field, i, j, k) : 0.0; int global_index = field_config_global_index(field_config , i , j , k); double exported_value = 0.0; if (ECL_GRDECL_FILE == file_type) exported_value = ecl_kw_iget_as_double(kw_exported, global_index); else if (RMS_ROFF_FILE == file_type) { exported_value = field_ijk_get_double(exported_field, i, j, k); } double initial_value = init_file ? ecl_kw_iget_as_double(kw_original, global_index) : 0.0; if (active) test_assert_double_equal(field_value, exported_value); else if (init_file) test_assert_double_equal(initial_value, exported_value); else if (file_type == RMS_ROFF_FILE) test_assert_double_equal(RMS_INACTIVE_DOUBLE, exported_value); else test_assert_double_equal(0.0, exported_value); } } } } if (init_file) { util_fclose(original_stream); ecl_kw_free(kw_original); } if (ECL_GRDECL_FILE == file_type) { util_fclose(exported_stream); ecl_kw_free(kw_exported); } else field_free(exported_field); }
void util_abort__(const char * file , const char * function , int line , const char * fmt , ...) { util_abort_test_intercept( function ); pthread_mutex_lock( &__abort_mutex ); /* Abort before unlock() */ { char * filename = NULL; FILE * abort_dump = NULL; if (!getenv("ERT_SHOW_BACKTRACE")) filename = util_alloc_dump_filename(); if (filename) abort_dump = fopen(filename, "w"); if (abort_dump == NULL) abort_dump = stderr; va_list ap; va_start(ap , fmt); fprintf(abort_dump , "\n\n"); fprintf(abort_dump , "Abort called from: %s (%s:%d) \n\n",function , file , line); fprintf(abort_dump , "Error message: "); vfprintf(abort_dump , fmt , ap); fprintf(abort_dump , "\n\n"); va_end(ap); /* The backtrace is based on calling the external program addr2line; the call is based on util_spawn() which is currently only available on POSIX. */ const bool include_backtrace = true; if (include_backtrace) { if (__abort_program_message != NULL) { #if !defined(__GLIBC__) /* allocate a temporary buffer to hold the path */ char* program_invocation_name = alloca (PATH_MAX); # if defined(__APPLE__) uint32_t buflen = PATH_MAX; _NSGetExecutablePath (program_invocation_name, &buflen); # elif defined(__LINUX__) readlink ("/proc/self/exe", program_invocation_name, PATH_MAX); # endif #endif /* !defined(__GLIBC__) */ fprintf(abort_dump,"--------------------------------------------------------------------------------\n"); fprintf(abort_dump,"%s",__abort_program_message); fprintf(abort_dump, "Current executable ..: %s\n" , program_invocation_name); fprintf(abort_dump,"--------------------------------------------------------------------------------\n"); } fprintf(abort_dump,"\n"); util_fprintf_backtrace( abort_dump ); } if (abort_dump != stderr) { util_fclose(abort_dump); fprintf(stderr, "\nError message: "); { va_list args; va_start(args , fmt); vfprintf(stderr , fmt , args); va_end(args); } fprintf(stderr, "\nSee file: %s for more details of the crash.\nSetting the environment variable \"ERT_SHOW_BACKTRACE\" will show the backtrace on stderr.\n", filename); } chmod(filename, 00644); // -rw-r--r-- free(filename); } pthread_mutex_unlock(&__abort_mutex); signal(SIGABRT, SIG_DFL); abort(); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- bool RifEclipseInputFileTools::openGridFile(const QString& fileName, RigEclipseCaseData* eclipseCase, bool readFaultData) { CVF_ASSERT(eclipseCase); std::vector< RifKeywordAndFilePos > keywordsAndFilePos; findKeywordsOnFile(fileName, &keywordsAndFilePos); qint64 coordPos = -1; qint64 zcornPos = -1; qint64 specgridPos = -1; qint64 actnumPos = -1; qint64 mapaxesPos = -1; findGridKeywordPositions(keywordsAndFilePos, &coordPos, &zcornPos, &specgridPos, &actnumPos, &mapaxesPos); if (coordPos < 0 || zcornPos < 0 || specgridPos < 0) { QString errorText = QString("Failed to import grid file '%1'\n").arg(fileName); if (coordPos < 0) { errorText += " Missing required keyword COORD"; } if (zcornPos < 0) { errorText += " Missing required keyword ZCORN"; } if (specgridPos < 0) { errorText += " Missing required keyword SPECGRID"; } RiaLogging::error(errorText); return false; } FILE* gridFilePointer = util_fopen(fileName.toLatin1().data(), "r"); if (!gridFilePointer) return false; // Main grid dimensions // SPECGRID - This is whats normally available, but not really the input to Eclipse. // DIMENS - Is what Eclipse expects and uses, but is not defined in the GRID section and is not (?) available normally // ZCORN, COORD, ACTNUM, MAPAXES //ecl_kw_type * ecl_kw_fscanf_alloc_grdecl_dynamic__( FILE * stream , const char * kw , bool strict , ecl_type_enum ecl_type); //ecl_grid_type * ecl_grid_alloc_GRDECL_kw( int nx, int ny , int nz , const ecl_kw_type * zcorn_kw , const ecl_kw_type * coord_kw , const ecl_kw_type * actnum_kw , const ecl_kw_type * mapaxes_kw ); ecl_kw_type* specGridKw = nullptr; ecl_kw_type* zCornKw = nullptr; ecl_kw_type* coordKw = nullptr; ecl_kw_type* actNumKw = nullptr; ecl_kw_type* mapAxesKw = nullptr; // Try to read all the needed keywords. Early exit if some are not found caf::ProgressInfo progress(8, "Read Grid from Eclipse Input file"); bool allKwReadOk = true; fseek(gridFilePointer, specgridPos, SEEK_SET); allKwReadOk = allKwReadOk && nullptr != (specGridKw = ecl_kw_fscanf_alloc_current_grdecl__(gridFilePointer, false , ecl_type_create_from_type(ECL_INT_TYPE))); progress.setProgress(1); fseek(gridFilePointer, zcornPos, SEEK_SET); allKwReadOk = allKwReadOk && nullptr != (zCornKw = ecl_kw_fscanf_alloc_current_grdecl__(gridFilePointer, false , ecl_type_create_from_type(ECL_FLOAT_TYPE))); progress.setProgress(2); fseek(gridFilePointer, coordPos, SEEK_SET); allKwReadOk = allKwReadOk && nullptr != (coordKw = ecl_kw_fscanf_alloc_current_grdecl__(gridFilePointer, false , ecl_type_create_from_type(ECL_FLOAT_TYPE))); progress.setProgress(3); // If ACTNUM is not defined, this pointer will be NULL, which is a valid condition if (actnumPos >= 0) { fseek(gridFilePointer, actnumPos, SEEK_SET); allKwReadOk = allKwReadOk && nullptr != (actNumKw = ecl_kw_fscanf_alloc_current_grdecl__(gridFilePointer, false , ecl_type_create_from_type(ECL_INT_TYPE))); progress.setProgress(4); } // If MAPAXES is not defined, this pointer will be NULL, which is a valid condition if (mapaxesPos >= 0) { fseek(gridFilePointer, mapaxesPos, SEEK_SET); mapAxesKw = ecl_kw_fscanf_alloc_current_grdecl__( gridFilePointer, false , ecl_type_create_from_type(ECL_FLOAT_TYPE)); } if (!allKwReadOk) { if(specGridKw) ecl_kw_free(specGridKw); if(zCornKw) ecl_kw_free(zCornKw); if(coordKw) ecl_kw_free(coordKw); if(actNumKw) ecl_kw_free(actNumKw); if(mapAxesKw) ecl_kw_free(mapAxesKw); return false; } progress.setProgress(5); int nx = ecl_kw_iget_int(specGridKw, 0); int ny = ecl_kw_iget_int(specGridKw, 1); int nz = ecl_kw_iget_int(specGridKw, 2); ecl_grid_type* inputGrid = ecl_grid_alloc_GRDECL_kw( nx, ny, nz, zCornKw, coordKw, actNumKw, mapAxesKw ); progress.setProgress(6); RifReaderEclipseOutput::transferGeometry(inputGrid, eclipseCase); progress.setProgress(7); progress.setProgressDescription("Read faults ..."); if (readFaultData) { cvf::Collection<RigFault> faults; RifEclipseInputFileTools::readFaults(fileName, keywordsAndFilePos, &faults); RigMainGrid* mainGrid = eclipseCase->mainGrid(); mainGrid->setFaults(faults); } progress.setProgress(8); progress.setProgressDescription("Cleaning up ..."); ecl_kw_free(specGridKw); ecl_kw_free(zCornKw); ecl_kw_free(coordKw); if (actNumKw) ecl_kw_free(actNumKw); if (mapAxesKw) ecl_kw_free(mapAxesKw); ecl_grid_free(inputGrid); util_fclose(gridFilePointer); return true; }