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;
}
