OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

#4683 clang-format on all files in ApplicationCode

Browse Source
This commit is contained in:
Magne Sjaastad
2019-09-06 10:40:57 +02:00
parent 3a317504bb
commit fe9e567825
2092 changed files with 117952 additions and 111846 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.cpp
View File

@@ -3,30 +3,30 @@
// Copyright (C) 2011- Statoil ASA
// Copyright (C) 2013- Ceetron Solutions AS
// Copyright (C) 2011-2012 Ceetron AS
//
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RifEclipseRestartFilesetAccess.h"
#include "RifEclipseOutputFileTools.h"
#include "RiaStringEncodingTools.h"
#include "RifEclipseOutputFileTools.h"
#include "cafProgressInfo.h"
#include "ert/ecl/ecl_file.h"
#include "ert/ecl/ecl_nnc_geometry.h"
#include "ert/ecl/ecl_nnc_data.h"
#include "ert/ecl/ecl_nnc_geometry.h"
//--------------------------------------------------------------------------------------------------
/// Constructor
@@ -43,16 +43,15 @@ RifEclipseRestartFilesetAccess::~RifEclipseRestartFilesetAccess()
{
close();
for (size_t i = 0; i < m_ecl_files.size(); i++)
for ( size_t i = 0; i < m_ecl_files.size(); i++ )
{
if (m_ecl_files[i])
if ( m_ecl_files[i] )
{
ecl_file_close(m_ecl_files[i]);
ecl_file_close( m_ecl_files[i] );
}
m_ecl_files[i] = nullptr;
}
}
//--------------------------------------------------------------------------------------------------
@@ -60,16 +59,16 @@ RifEclipseRestartFilesetAccess::~RifEclipseRestartFilesetAccess()
//--------------------------------------------------------------------------------------------------
bool RifEclipseRestartFilesetAccess::open()
{
if (m_fileNames.size() > 0)
if ( m_fileNames.size() > 0 )
{
caf::ProgressInfo progInfo(m_fileNames.size(), "");
caf::ProgressInfo progInfo( m_fileNames.size(), "" );
int i;
for (i = 0; i < m_fileNames.size(); i++)
for ( i = 0; i < m_fileNames.size(); i++ )
{
progInfo.setProgressDescription(m_fileNames[i]);
progInfo.setProgressDescription( m_fileNames[i] );
openTimeStep(i);
openTimeStep( i );
progInfo.incrementProgress();
}
@@ -79,9 +78,9 @@ bool RifEclipseRestartFilesetAccess::open()
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void RifEclipseRestartFilesetAccess::setRestartFiles(const QStringList& fileSet)
void RifEclipseRestartFilesetAccess::setRestartFiles( const QStringList& fileSet )
{
close();
m_ecl_files.clear();
@@ -89,27 +88,25 @@ void RifEclipseRestartFilesetAccess::setRestartFiles(const QStringList& fileSet)
m_fileNames = fileSet;
m_fileNames.sort(); // To make sure they are sorted in increasing *.X000N order. Hack. Should probably be actual time stored on file.
for (int i = 0; i < m_fileNames.size(); i++)
for ( int i = 0; i < m_fileNames.size(); i++ )
{
m_ecl_files.push_back(nullptr);
m_ecl_files.push_back( nullptr );
}
CVF_ASSERT(m_fileNames.size() == static_cast<int>(m_ecl_files.size()));
CVF_ASSERT( m_fileNames.size() == static_cast<int>( m_ecl_files.size() ) );
}
//--------------------------------------------------------------------------------------------------
/// Close files
//--------------------------------------------------------------------------------------------------
void RifEclipseRestartFilesetAccess::close()
{
}
void RifEclipseRestartFilesetAccess::close() {}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void RifEclipseRestartFilesetAccess::setTimeSteps(const std::vector<QDateTime>& timeSteps)
void RifEclipseRestartFilesetAccess::setTimeSteps( const std::vector<QDateTime>& timeSteps )
{
CVF_ASSERT((size_t)m_fileNames.size() == timeSteps.size());
CVF_ASSERT( (size_t)m_fileNames.size() == timeSteps.size() );
m_timeSteps = timeSteps;
}
@@ -124,93 +121,96 @@ size_t RifEclipseRestartFilesetAccess::timeStepCount()
//--------------------------------------------------------------------------------------------------
/// Get the time steps
//--------------------------------------------------------------------------------------------------
void RifEclipseRestartFilesetAccess::timeSteps(std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart)
void RifEclipseRestartFilesetAccess::timeSteps( std::vector<QDateTime>* timeSteps,
std::vector<double>* daysSinceSimulationStart )
{
if (m_timeSteps.size() == 0)
if ( m_timeSteps.size() == 0 )
{
size_t numSteps = m_fileNames.size();
size_t i;
for (i = 0; i < numSteps; i++)
for ( i = 0; i < numSteps; i++ )
{
std::vector<QDateTime> stepTime;
std::vector<double> stepDays;
std::vector<double> stepDays;
openTimeStep(i);
openTimeStep( i );
RifEclipseOutputFileTools::timeSteps(m_ecl_files[i], &stepTime, &stepDays);
if (stepTime.size() == 1)
RifEclipseOutputFileTools::timeSteps( m_ecl_files[i], &stepTime, &stepDays );
if ( stepTime.size() == 1 )
{
m_timeSteps.push_back(stepTime[0]);
m_daysSinceSimulationStart.push_back(stepDays[0]);
m_timeSteps.push_back( stepTime[0] );
m_daysSinceSimulationStart.push_back( stepDays[0] );
}
else
{
m_timeSteps.push_back(QDateTime());
m_daysSinceSimulationStart.push_back(0.0);
m_timeSteps.push_back( QDateTime() );
m_daysSinceSimulationStart.push_back( 0.0 );
}
}
}
*timeSteps = m_timeSteps;
*timeSteps = m_timeSteps;
*daysSinceSimulationStart = m_daysSinceSimulationStart;
}
//--------------------------------------------------------------------------------------------------
/// Get list of result names
//--------------------------------------------------------------------------------------------------
void RifEclipseRestartFilesetAccess::resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts)
void RifEclipseRestartFilesetAccess::resultNames( QStringList* resultNames, std::vector<size_t>* resultDataItemCounts )
{
CVF_ASSERT(timeStepCount() > 0);
CVF_ASSERT( timeStepCount() > 0 );
for (int i = 0; i < m_fileNames.size(); i++)
for ( int i = 0; i < m_fileNames.size(); i++ )
{
openTimeStep(i);
openTimeStep( i );
}
RifEclipseOutputFileTools::findKeywordsAndItemCount(m_ecl_files, resultNames, resultDataItemCounts);
RifEclipseOutputFileTools::findKeywordsAndItemCount( m_ecl_files, resultNames, resultDataItemCounts );
}
//--------------------------------------------------------------------------------------------------
/// Get result values for given time step
//--------------------------------------------------------------------------------------------------
bool RifEclipseRestartFilesetAccess::results(const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values)
bool RifEclipseRestartFilesetAccess::results( const QString& resultName,
size_t timeStep,
size_t gridCount,
std::vector<double>* values )
{
if (timeStep >= timeStepCount())
if ( timeStep >= timeStepCount() )
{
return false;
}
openTimeStep(timeStep);
openTimeStep( timeStep );
if (!m_ecl_files[timeStep])
if ( !m_ecl_files[timeStep] )
{
return false;
}
size_t fileGridCount = ecl_file_get_num_named_kw(m_ecl_files[timeStep], resultName.toLatin1().data());
size_t fileGridCount = ecl_file_get_num_named_kw( m_ecl_files[timeStep], resultName.toLatin1().data() );
// No results for this result variable for current time step found
if (fileGridCount == 0) return true;
if ( fileGridCount == 0 ) return true;
// Result handling depends on presents of result values for all grids
if (gridCount != fileGridCount)
if ( gridCount != fileGridCount )
{
return false;
}
size_t i;
for (i = 0; i < fileGridCount; i++)
for ( i = 0; i < fileGridCount; i++ )
{
std::vector<double> gridValues;
if (!RifEclipseOutputFileTools::keywordData(m_ecl_files[timeStep], resultName, i, &gridValues))
if ( !RifEclipseOutputFileTools::keywordData( m_ecl_files[timeStep], resultName, i, &gridValues ) )
{
return false;
}
values->insert(values->end(), gridValues.begin(), gridValues.end());
values->insert( values->end(), gridValues.begin(), gridValues.end() );
}
return true;
@@ -219,23 +219,27 @@ bool RifEclipseRestartFilesetAccess::results(const QString& resultName, size_t t
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseRestartFilesetAccess::dynamicNNCResults(const ecl_grid_type* grid, size_t timeStep, std::vector<double>* waterFlux, std::vector<double>* oilFlux, std::vector<double>* gasFlux)
bool RifEclipseRestartFilesetAccess::dynamicNNCResults( const ecl_grid_type* grid,
size_t timeStep,
std::vector<double>* waterFlux,
std::vector<double>* oilFlux,
std::vector<double>* gasFlux )
{
if (timeStep > timeStepCount())
if ( timeStep > timeStepCount() )
{
return false;
}
openTimeStep(timeStep);
openTimeStep( timeStep );
if (!m_ecl_files[timeStep])
if ( !m_ecl_files[timeStep] )
{
return false;
}
ecl_file_view_type* summaryView = ecl_file_get_global_view(m_ecl_files[timeStep]);
ecl_file_view_type* summaryView = ecl_file_get_global_view( m_ecl_files[timeStep] );
RifEclipseOutputFileTools::transferNncFluxData(grid, summaryView, waterFlux, oilFlux, gasFlux);
RifEclipseOutputFileTools::transferNncFluxData( grid, summaryView, waterFlux, oilFlux, gasFlux );
return true;
}
@@ -243,83 +247,84 @@ bool RifEclipseRestartFilesetAccess::dynamicNNCResults(const ecl_grid_type* grid
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifEclipseRestartFilesetAccess::readWellData(well_info_type* well_info, bool importCompleteMswData)
void RifEclipseRestartFilesetAccess::readWellData( well_info_type* well_info, bool importCompleteMswData )
{
if (!well_info) return;
if ( !well_info ) return;
for (size_t i = 0; i < m_ecl_files.size(); i++)
for ( size_t i = 0; i < m_ecl_files.size(); i++ )
{
openTimeStep(i);
openTimeStep( i );
if (m_ecl_files[i])
if ( m_ecl_files[i] )
{
int reportNumber = RifEclipseRestartFilesetAccess::reportNumber(m_ecl_files[i]);
if(reportNumber != -1)
int reportNumber = RifEclipseRestartFilesetAccess::reportNumber( m_ecl_files[i] );
if ( reportNumber != -1 )
{
well_info_add_wells(well_info, m_ecl_files[i], reportNumber, importCompleteMswData);
well_info_add_wells( well_info, m_ecl_files[i], reportNumber, importCompleteMswData );
}
}
}
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
void RifEclipseRestartFilesetAccess::openTimeStep(size_t timeStep)
void RifEclipseRestartFilesetAccess::openTimeStep( size_t timeStep )
{
CVF_ASSERT(timeStep < m_ecl_files.size());
CVF_ASSERT( timeStep < m_ecl_files.size() );
if (m_ecl_files[timeStep] == nullptr)
if ( m_ecl_files[timeStep] == nullptr )
{
int index = static_cast<int>(timeStep);
ecl_file_type* ecl_file = ecl_file_open(RiaStringEncodingTools::toNativeEncoded(m_fileNames[index]).data(), ECL_FILE_CLOSE_STREAM);
int index = static_cast<int>( timeStep );
ecl_file_type* ecl_file = ecl_file_open( RiaStringEncodingTools::toNativeEncoded( m_fileNames[index] ).data(),
ECL_FILE_CLOSE_STREAM );
m_ecl_files[timeStep] = ecl_file;
if (ecl_file)
if ( ecl_file )
{
auto phases = RifEclipseOutputFileTools::findAvailablePhases(ecl_file);
auto phases = RifEclipseOutputFileTools::findAvailablePhases( ecl_file );
m_availablePhases.insert(phases.begin(), phases.end());
m_availablePhases.insert( phases.begin(), phases.end() );
}
}
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
int RifEclipseRestartFilesetAccess::reportNumber(const ecl_file_type* ecl_file)
int RifEclipseRestartFilesetAccess::reportNumber( const ecl_file_type* ecl_file )
{
if (!ecl_file) return -1;
if ( !ecl_file ) return -1;
const char* eclFileName = ecl_file_get_src_file(ecl_file);
QString fileNameUpper(eclFileName);
const char* eclFileName = ecl_file_get_src_file( ecl_file );
QString fileNameUpper( eclFileName );
fileNameUpper = fileNameUpper.toUpper();
// Convert to upper case, as ecl_util_filename_report_nr does not handle lower case file extensions
int reportNumber = ecl_util_filename_report_nr(RiaStringEncodingTools::toNativeEncoded(fileNameUpper).data());
int reportNumber = ecl_util_filename_report_nr( RiaStringEncodingTools::toNativeEncoded( fileNameUpper ).data() );
return reportNumber;
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
int RifEclipseRestartFilesetAccess::readUnitsType()
{
ecl_file_type* ecl_file = nullptr;
if (m_ecl_files.size() > 0)
if ( m_ecl_files.size() > 0 )
{
openTimeStep(0);
openTimeStep( 0 );
ecl_file = m_ecl_files[0];
}
return RifEclipseOutputFileTools::readUnitsType(ecl_file);
return RifEclipseOutputFileTools::readUnitsType( ecl_file );
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
std::set<RiaDefines::PhaseType> RifEclipseRestartFilesetAccess::availablePhases() const
{
@@ -327,24 +332,23 @@ std::set<RiaDefines::PhaseType> RifEclipseRestartFilesetAccess::availablePhases(
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
std::vector<int> RifEclipseRestartFilesetAccess::reportNumbers()
{
std::vector<int> reportNr;
for (const auto* ecl_file : m_ecl_files)
for ( const auto* ecl_file : m_ecl_files )
{
if (ecl_file)
if ( ecl_file )
{
int reportNumber = RifEclipseRestartFilesetAccess::reportNumber(ecl_file);
if (reportNumber != -1)
int reportNumber = RifEclipseRestartFilesetAccess::reportNumber( ecl_file );
if ( reportNumber != -1 )
{
reportNr.push_back(reportNumber);
reportNr.push_back( reportNumber );
}
}
}
return reportNr;
}