//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifEclipseSummaryTools::findSummaryHeaderFileInfo(const std::string& inputFile, std::string* headerFile, std::string* path, std::string* base, bool* isFormatted)
{
char* myPath = NULL;
char* myBase = NULL;
bool formattedFile = true;
util_alloc_file_components(inputFile.data(), &myPath, &myBase, NULL);
char* myHeaderFile = ecl_util_alloc_exfilename(myPath, myBase, ECL_SUMMARY_HEADER_FILE, true, -1);
if (!myHeaderFile)
{
myHeaderFile = ecl_util_alloc_exfilename(myPath, myBase, ECL_SUMMARY_HEADER_FILE, false, -1);
if (myHeaderFile)
{
formattedFile = false;
}
}
if (myHeaderFile && headerFile) *headerFile = myHeaderFile;
if (myPath && path) *path = myPath;
if (myBase && base) *base = myBase;
if (isFormatted) *isFormatted = formattedFile;
util_safe_free(myHeaderFile);
util_safe_free(myBase);
util_safe_free(myPath);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifEclipseSummaryTools::findSummaryHeaderFileInfo(const QString& inputFile, QString* headerFile, QString* path, QString* base, bool* isFormatted)
{
char* myPath = nullptr;
char* myBase = nullptr;
bool formattedFile = true;
util_alloc_file_components(RiaStringEncodingTools::toNativeEncoded(QDir::toNativeSeparators(inputFile)).data(), &myPath, &myBase, nullptr);
char* myHeaderFile = ecl_util_alloc_exfilename(myPath, myBase, ECL_SUMMARY_HEADER_FILE, true, -1);
if (!myHeaderFile)
{
myHeaderFile = ecl_util_alloc_exfilename(myPath, myBase, ECL_SUMMARY_HEADER_FILE, false, -1);
if (myHeaderFile)
{
formattedFile = false;
}
}
if (myHeaderFile && headerFile) *headerFile = RiaFilePathTools::toInternalSeparator(myHeaderFile);
if (myPath && path) *path = RiaFilePathTools::toInternalSeparator(myPath);
if (myBase && base) *base = RiaFilePathTools::toInternalSeparator(myBase);
if (isFormatted) *isFormatted = formattedFile;
util_safe_free(myHeaderFile);
util_safe_free(myBase);
util_safe_free(myPath);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile(const QString& summaryHeaderFile)
{
char* myPath = nullptr;
char* myBase = nullptr;
bool formattedFile = true;
util_alloc_file_components(RiaStringEncodingTools::toNativeEncoded(QDir::toNativeSeparators(summaryHeaderFile)).data(), &myPath, &myBase, nullptr);
char* caseFile = ecl_util_alloc_exfilename(myPath, myBase, ECL_EGRID_FILE, true, -1);
if (!caseFile)
{
caseFile= ecl_util_alloc_exfilename(myPath, myBase, ECL_EGRID_FILE, false, -1);
if (caseFile)
{
formattedFile = false;
}
}
QString gridCaseFile;
if (caseFile) gridCaseFile = caseFile;
util_safe_free(caseFile);
util_safe_free(myBase);
util_safe_free(myPath);
return RiaFilePathTools::toInternalSeparator(gridCaseFile);
}
void ecl_util_alloc_summary_data_files(const char * path , const char * base , bool fmt_file , stringlist_type * filelist) {
char * unif_data_file = ecl_util_alloc_exfilename(path , base , ECL_UNIFIED_SUMMARY_FILE , fmt_file , -1);
int files = ecl_util_select_filelist( path , base , ECL_SUMMARY_FILE , fmt_file , filelist);
if ((files > 0) && (unif_data_file != NULL)) {
/*
We have both a unified file AND a list of files: BASE.S0000,
BASE.S0001, BASE.S0002, ..., must check which is newest and
load accordingly.
*/
bool unified_newest = true;
int file_nr = 0;
while (unified_newest && (file_nr < files)) {
if (util_file_difftime( stringlist_iget(filelist , file_nr) , unif_data_file ) > 0)
unified_newest = false;
file_nr++;
}
if (unified_newest) {
stringlist_clear( filelist ); /* Clear out all the BASE.Snnnn selections. */
stringlist_append_copy( filelist , unif_data_file );
}
} else if (unif_data_file != NULL) {
/* Found a unified summary file : Clear out all the BASE.Snnnn selections. */
stringlist_clear( filelist ); /* Clear out all the BASE.Snnnn selections. */
stringlist_append_copy( filelist , unif_data_file );
}
util_safe_free( unif_data_file );
}
bool ecl_sum_same_case( const ecl_sum_type * ecl_sum , const char * input_file ) {
bool same_case = false;
{
char * path;
char * base;
util_alloc_file_components( input_file , &path , &base , NULL);
{
bool fmt_file = ecl_smspec_get_formatted( ecl_sum->smspec );
char * header_file = ecl_util_alloc_exfilename( path , base , ECL_SUMMARY_HEADER_FILE , fmt_file , -1 );
if (header_file != NULL) {
same_case = util_same_file( header_file , ecl_smspec_get_header_file( ecl_sum->smspec ));
free( header_file );
}
}
util_safe_free( path );
util_safe_free( base );
}
return same_case;
}
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;
}
