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

#1068 Renamed to RigEclipseCaseData

Browse Source
This commit is contained in:
Magne Sjaastad 2017-01-10 09:51:39 +01:00
parent 36c008a12c
commit 8970d93a4d
83 changed files with 265 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/Application/RiaApplication.h
View File

@ -43,7 +43,7 @@ class RiaPreferences;
class RiaProjectModifier;
class RiaSocketServer;
class RigCaseData;
class RigEclipseCaseData;
class RimCommandObject;
class RimEclipseCase;

2
ApplicationCode/Commands/RicExportFaultsFeature.cpp
View File

@ -21,7 +21,7 @@
#include "RiaApplication.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigFault.h"
#include "RigMainGrid.h"

16
ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
View File

@ -24,7 +24,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RigResultAccessorFactory.h"
@ -73,7 +73,7 @@ RifEclipseInputFileTools::~RifEclipseInputFileTools()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseInputFileTools::openGridFile(const QString& fileName, RigCaseData* eclipseCase, bool readFaultData)
bool RifEclipseInputFileTools::openGridFile(const QString& fileName, RigEclipseCaseData* eclipseCase, bool readFaultData)
{
CVF_ASSERT(eclipseCase);
@ -202,7 +202,7 @@ bool RifEclipseInputFileTools::openGridFile(const QString& fileName, RigCaseData
//--------------------------------------------------------------------------------------------------
/// Read known properties from the input file
//--------------------------------------------------------------------------------------------------
std::map<QString, QString> RifEclipseInputFileTools::readProperties(const QString& fileName, RigCaseData* caseData)
std::map<QString, QString> RifEclipseInputFileTools::readProperties(const QString& fileName, RigEclipseCaseData* caseData)
{
CVF_ASSERT(caseData);
@ -252,7 +252,7 @@ std::map<QString, QString> RifEclipseInputFileTools::readProperties(const QStrin
/// Reads the property data requested into the \a reservoir, overwriting any previous
/// properties with the same name.
//--------------------------------------------------------------------------------------------------
bool RifEclipseInputFileTools::readProperty(const QString& fileName, RigCaseData* caseData, const QString& eclipseKeyWord, const QString& resultName)
bool RifEclipseInputFileTools::readProperty(const QString& fileName, RigEclipseCaseData* caseData, const QString& eclipseKeyWord, const QString& resultName)
{
CVF_ASSERT(caseData);
@ -278,7 +278,7 @@ bool RifEclipseInputFileTools::readProperty(const QString& fileName, RigCaseData
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseInputFileTools::readDataFromKeyword(ecl_kw_type* eclipseKeywordData, RigCaseData* caseData, const QString& resultName)
bool RifEclipseInputFileTools::readDataFromKeyword(ecl_kw_type* eclipseKeywordData, RigEclipseCaseData* caseData, const QString& resultName)
{
CVF_ASSERT(caseData);
CVF_ASSERT(eclipseKeywordData);
@ -443,7 +443,7 @@ const std::vector<QString>& RifEclipseInputFileTools::invalidPropertyDataKeyword
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseInputFileTools::writePropertyToTextFile(const QString& fileName, RigCaseData* eclipseCase, size_t timeStep, const QString& resultName, const QString& eclipseKeyWord)
bool RifEclipseInputFileTools::writePropertyToTextFile(const QString& fileName, RigEclipseCaseData* eclipseCase, size_t timeStep, const QString& resultName, const QString& eclipseKeyWord)
{
CVF_ASSERT(eclipseCase);
@ -476,7 +476,7 @@ bool RifEclipseInputFileTools::writePropertyToTextFile(const QString& fileName,
/// undefinedValue is used for cells with no result
//--------------------------------------------------------------------------------------------------
bool RifEclipseInputFileTools::writeBinaryResultToTextFile(const QString& fileName,
RigCaseData* eclipseCase,
RigEclipseCaseData* eclipseCase,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStep,
const QString& resultName,
@ -723,7 +723,7 @@ qint64 RifEclipseInputFileTools::findKeyword(const QString& keyword, QFile& file
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RifEclipseInputFileTools::findOrCreateResult(const QString& newResultName, RigCaseData* reservoir)
size_t RifEclipseInputFileTools::findOrCreateResult(const QString& newResultName, RigEclipseCaseData* reservoir)
{
size_t resultIndex = reservoir->results(RifReaderInterface::MATRIX_RESULTS)->findScalarResultIndex(newResultName);
if (resultIndex == cvf::UNDEFINED_SIZE_T)

16
ApplicationCode/FileInterface/RifEclipseInputFileTools.h
View File

@ -34,7 +34,7 @@
#include <QString>
class RigCaseData;
class RigEclipseCaseData;
class QFile;
@ -59,11 +59,11 @@ public:
RifEclipseInputFileTools();
virtual ~RifEclipseInputFileTools();
static bool openGridFile(const QString& fileName, RigCaseData* eclipseCase, bool readFaultData);
static bool openGridFile(const QString& fileName, RigEclipseCaseData* eclipseCase, bool readFaultData);
// Returns map of assigned resultName and Eclipse Keyword.
static std::map<QString, QString> readProperties(const QString& fileName, RigCaseData* eclipseCase);
static bool readProperty (const QString& fileName, RigCaseData* eclipseCase, const QString& eclipseKeyWord, const QString& resultName );
static std::map<QString, QString> readProperties(const QString& fileName, RigEclipseCaseData* eclipseCase);
static bool readProperty (const QString& fileName, RigEclipseCaseData* eclipseCase, const QString& eclipseKeyWord, const QString& resultName );
static void readFaultsInGridSection(const QString& fileName, cvf::Collection<RigFault>* faults, std::vector<QString>* filenamesWithFaults);
static void readFaults(const QString& fileName, const std::vector< RifKeywordAndFilePos >& fileKeywords, cvf::Collection<RigFault>* faults);
@ -75,8 +75,8 @@ public:
static void parseAndReadPathAliasKeyword(const QString &fileName, std::vector< std::pair<QString, QString> >* pathAliasDefinitions);
static bool writePropertyToTextFile(const QString& fileName, RigCaseData* eclipseCase, size_t timeStep, const QString& resultName, const QString& eclipseKeyWord);
static bool writeBinaryResultToTextFile(const QString& fileName, RigCaseData* eclipseCase, RifReaderInterface::PorosityModelResultType porosityModel, size_t timeStep, const QString& resultName, const QString& eclipseKeyWord, const double undefinedValue);
static bool writePropertyToTextFile(const QString& fileName, RigEclipseCaseData* eclipseCase, size_t timeStep, const QString& resultName, const QString& eclipseKeyWord);
static bool writeBinaryResultToTextFile(const QString& fileName, RigEclipseCaseData* eclipseCase, RifReaderInterface::PorosityModelResultType porosityModel, size_t timeStep, const QString& resultName, const QString& eclipseKeyWord, const double undefinedValue);
static bool readFaultsAndParseIncludeStatementsRecursively( QFile& file,
qint64 startPos,
@ -88,14 +88,14 @@ public:
static cvf::StructGridInterface::FaceEnum faceEnumFromText(const QString& faceString);
private:
static bool readDataFromKeyword(ecl_kw_type* eclipseKeywordData, RigCaseData* caseData, const QString& resultName);
static bool readDataFromKeyword(ecl_kw_type* eclipseKeywordData, RigEclipseCaseData* caseData, const QString& resultName);
static void writeDataToTextFile(QFile* file, const QString& eclipseKeyWord, const std::vector<double>& resultData);
static void findGridKeywordPositions(const std::vector< RifKeywordAndFilePos >& keywords, qint64* coordPos, qint64* zcornPos, qint64* specgridPos, qint64* actnumPos, qint64* mapaxesPos);
static size_t findFaultByName(const cvf::Collection<RigFault>& faults, const QString& name);
static qint64 findKeyword(const QString& keyword, QFile& file, qint64 startPos);
static size_t findOrCreateResult(const QString& newResultName, RigCaseData* reservoir);
static size_t findOrCreateResult(const QString& newResultName, RigEclipseCaseData* reservoir);
static bool isValidDataKeyword(const QString& keyword);
private:

4
ApplicationCode/FileInterface/RifReaderEclipseInput.cpp
View File

@ -22,7 +22,7 @@
#include "RifEclipseInputFileTools.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
//==================================================================================================
@ -48,7 +48,7 @@ RifReaderEclipseInput::~RifReaderEclipseInput()
//--------------------------------------------------------------------------------------------------
/// Open file and read geometry into given reservoir object
//--------------------------------------------------------------------------------------------------
bool RifReaderEclipseInput::open(const QString& fileName, RigCaseData* eclipseCase)
bool RifReaderEclipseInput::open(const QString& fileName, RigEclipseCaseData* eclipseCase)
{
CVF_ASSERT(eclipseCase);

2
ApplicationCode/FileInterface/RifReaderEclipseInput.h
View File

@ -32,7 +32,7 @@ public:
virtual ~RifReaderEclipseInput();
// Virtual interface implementation
virtual bool open(const QString& fileName, RigCaseData* eclipseCase);
virtual bool open(const QString& fileName, RigEclipseCaseData* eclipseCase);

14
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -22,7 +22,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RifEclipseOutputFileTools.h"
@ -231,7 +231,7 @@ void RifReaderEclipseOutput::close()
//--------------------------------------------------------------------------------------------------
/// Read geometry from file given by name into given reservoir object
//--------------------------------------------------------------------------------------------------
bool RifReaderEclipseOutput::transferGeometry(const ecl_grid_type* mainEclGrid, RigCaseData* eclipseCase)
bool RifReaderEclipseOutput::transferGeometry(const ecl_grid_type* mainEclGrid, RigEclipseCaseData* eclipseCase)
{
CVF_ASSERT(eclipseCase);
@ -349,7 +349,7 @@ bool RifReaderEclipseOutput::transferGeometry(const ecl_grid_type* mainEclGrid,
//--------------------------------------------------------------------------------------------------
/// Open file and read geometry into given reservoir object
//--------------------------------------------------------------------------------------------------
bool RifReaderEclipseOutput::open(const QString& fileName, RigCaseData* eclipseCase)
bool RifReaderEclipseOutput::open(const QString& fileName, RigEclipseCaseData* eclipseCase)
{
CVF_ASSERT(eclipseCase);
caf::ProgressInfo progInfo(100, "");
@ -523,7 +523,7 @@ void RifReaderEclipseOutput::transferNNCData( const ecl_grid_type * mainEclGrid
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifReaderEclipseOutput::openAndReadActiveCellData(const QString& fileName, const std::vector<QDateTime>& mainCaseTimeSteps, RigCaseData* eclipseCase)
bool RifReaderEclipseOutput::openAndReadActiveCellData(const QString& fileName, const std::vector<QDateTime>& mainCaseTimeSteps, RigEclipseCaseData* eclipseCase)
{
CVF_ASSERT(eclipseCase);
@ -704,16 +704,16 @@ void RifReaderEclipseOutput::buildMetaData()
}
// Default units type is METRIC
RigCaseData::UnitsType unitsType = RigCaseData::UNITS_METRIC;
RigEclipseCaseData::UnitsType unitsType = RigEclipseCaseData::UNITS_METRIC;
{
int unitsTypeValue = m_dynamicResultsAccess->readUnitsType();
if (unitsTypeValue == 2)
{
unitsType = RigCaseData::UNITS_FIELD;
unitsType = RigEclipseCaseData::UNITS_FIELD;
}
else if (unitsTypeValue == 3)
{
unitsType = RigCaseData::UNITS_LAB;
unitsType = RigEclipseCaseData::UNITS_LAB;
}
}

8
ApplicationCode/FileInterface/RifReaderEclipseOutput.h
View File

@ -49,15 +49,15 @@ public:
RifReaderEclipseOutput();
virtual ~RifReaderEclipseOutput();
bool open(const QString& fileName, RigCaseData* eclipseCase);
bool open(const QString& fileName, RigEclipseCaseData* eclipseCase);
virtual bool openAndReadActiveCellData(const QString& fileName, const std::vector<QDateTime>& mainCaseTimeSteps, RigCaseData* eclipseCase);
virtual bool openAndReadActiveCellData(const QString& fileName, const std::vector<QDateTime>& mainCaseTimeSteps, RigEclipseCaseData* eclipseCase);
void close();
bool staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values);
bool dynamicResult(const QString& result, PorosityModelResultType matrixOrFracture, size_t stepIndex, std::vector<double>* values);
static bool transferGeometry(const ecl_grid_type* mainEclGrid, RigCaseData* eclipseCase);
static bool transferGeometry(const ecl_grid_type* mainEclGrid, RigEclipseCaseData* eclipseCase);
static void transferCoarseningInfo(const ecl_grid_type* eclGrid, RigGridBase* grid);
private:
@ -89,7 +89,7 @@ private:
QString m_fileName; // Name of file used to start accessing Eclipse output files
QStringList m_filesWithSameBaseName; // Set of files in filename's path with same base name as filename
RigCaseData* m_eclipseCase;
RigEclipseCaseData* m_eclipseCase;
std::vector<QDateTime> m_timeSteps;

4
ApplicationCode/FileInterface/RifReaderInterface.h
View File

@ -31,7 +31,7 @@
#include <QDateTime>
class RigCaseData;
class RigEclipseCaseData;
class RifReaderSettings;
@ -59,7 +59,7 @@ public:
bool isImportOfCompleteMswDataEnabled();
bool isNNCsEnabled();
virtual bool open(const QString& fileName, RigCaseData* eclipseCase) = 0;
virtual bool open(const QString& fileName, RigEclipseCaseData* eclipseCase) = 0;
virtual void close() = 0;
virtual bool staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values) = 0;

6
ApplicationCode/FileInterface/RifReaderMockModel.cpp
View File

@ -23,12 +23,12 @@
#include "RifReaderInterface.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifReaderMockModel::open(const QString& fileName, RigCaseData* eclipseCase)
bool RifReaderMockModel::open(const QString& fileName, RigEclipseCaseData* eclipseCase)
{
m_reservoirBuilder.populateReservoir(eclipseCase);
@ -173,7 +173,7 @@ void RifReaderMockModel::addLocalGridRefinement(const cvf::Vec3st& minCellPositi
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifReaderMockModel::populateReservoir(RigCaseData* eclipseCase)
void RifReaderMockModel::populateReservoir(RigEclipseCaseData* eclipseCase)
{
m_reservoirBuilder.populateReservoir(eclipseCase);
}

6
ApplicationCode/FileInterface/RifReaderMockModel.h
View File

@ -36,17 +36,17 @@ public:
void addLocalGridRefinement(const cvf::Vec3st& minCellPosition, const cvf::Vec3st& maxCellPosition, const cvf::Vec3st& singleCellRefinementFactors);
virtual bool open( const QString& fileName, RigCaseData* eclipseCase );
virtual bool open( const QString& fileName, RigEclipseCaseData* eclipseCase );
virtual void close();
virtual bool staticResult( const QString& result, RifReaderInterface::PorosityModelResultType matrixOrFracture, std::vector<double>* values );
virtual bool dynamicResult( const QString& result, RifReaderInterface::PorosityModelResultType matrixOrFracture, size_t stepIndex, std::vector<double>* values );
private:
void populateReservoir(RigCaseData* eclipseCase);
void populateReservoir(RigEclipseCaseData* eclipseCase);
bool inputProperty( const QString& propertyName, std::vector<double>* values );
RigReservoirBuilderMock m_reservoirBuilder;
RigCaseData* m_reservoir;
RigEclipseCaseData* m_reservoir;
};

12
ApplicationCode/FileInterface/RifReaderOpmParserInput.cpp
View File

@ -20,7 +20,7 @@
#include "RifReaderEclipseOutput.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RimEclipseInputCaseOpm.h"
@ -45,7 +45,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifReaderOpmParserInput::importGridPropertiesFaults(const QString& fileName, RigCaseData* caseData)
void RifReaderOpmParserInput::importGridPropertiesFaults(const QString& fileName, RigEclipseCaseData* caseData)
{
RiuMainWindow::instance()->processMonitor()->addStringToLog(QString("\nStarted reading of grid and properties from file : " + fileName + "\n"));
@ -432,7 +432,7 @@ void RifReaderOpmParserInput::initUsingWarnings(Opm::ParseContext* parseContext)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RifReaderOpmParserPropertyReader::findOrCreateResult(const QString& newResultName, RigCaseData* reservoir)
size_t RifReaderOpmParserPropertyReader::findOrCreateResult(const QString& newResultName, RigEclipseCaseData* reservoir)
{
size_t resultIndex = reservoir->results(RifReaderInterface::MATRIX_RESULTS)->findScalarResultIndex(newResultName);
if (resultIndex == cvf::UNDEFINED_SIZE_T)
@ -446,7 +446,7 @@ size_t RifReaderOpmParserPropertyReader::findOrCreateResult(const QString& newRe
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifReaderOpmParserPropertyReader::readAllProperties(std::shared_ptr< Opm::Deck > deck, RigCaseData* caseData, std::map<QString, QString>* newResults)
void RifReaderOpmParserPropertyReader::readAllProperties(std::shared_ptr< Opm::Deck > deck, RigEclipseCaseData* caseData, std::map<QString, QString>* newResults)
{
std::set<std::string> uniqueKeywords;
for (auto it = deck->begin(); it != deck->end(); it++)
@ -549,7 +549,7 @@ std::set<std::string> RifReaderOpmParserPropertyReader::keywords() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifReaderOpmParserPropertyReader::copyPropertyToCaseData(const std::string& keywordName, RigCaseData* caseData, const QString& resultName)
bool RifReaderOpmParserPropertyReader::copyPropertyToCaseData(const std::string& keywordName, RigEclipseCaseData* caseData, const QString& resultName)
{
{
std::string errorMessage;
@ -629,7 +629,7 @@ void RifReaderOpmParserPropertyReader::getAllValuesForKeyword(std::shared_ptr< O
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifReaderOpmParserPropertyReader::isDataItemCountIdenticalToMainGridCellCount(std::shared_ptr< Opm::Deck > deck, const std::string& keyword, RigCaseData* caseData)
bool RifReaderOpmParserPropertyReader::isDataItemCountIdenticalToMainGridCellCount(std::shared_ptr< Opm::Deck > deck, const std::string& keyword, RigEclipseCaseData* caseData)
{
bool isEqual = false;
{

12
ApplicationCode/FileInterface/RifReaderOpmParserInput.h
View File

@ -30,7 +30,7 @@
#include <QString>
class RigCaseData;
class RigEclipseCaseData;
namespace Opm {
class Deck;
@ -46,7 +46,7 @@ namespace Opm {
class RifReaderOpmParserInput
{
public:
static void importGridPropertiesFaults(const QString& fileName, RigCaseData* eclipseCase);
static void importGridPropertiesFaults(const QString& fileName, RigEclipseCaseData* eclipseCase);
static void readFaults(const QString& fileName, cvf::Collection<RigFault>* faults);
@ -75,14 +75,14 @@ public:
std::set<std::string> keywords() const;
bool copyPropertyToCaseData(const std::string& keywordName, RigCaseData* eclipseCase, const QString& resultName);
bool copyPropertyToCaseData(const std::string& keywordName, RigEclipseCaseData* eclipseCase, const QString& resultName);
static size_t findOrCreateResult(const QString& newResultName, RigCaseData* reservoir);
static size_t findOrCreateResult(const QString& newResultName, RigEclipseCaseData* reservoir);
private:
static void readAllProperties(std::shared_ptr< Opm::Deck > deck, RigCaseData* caseData, std::map<QString, QString>* newResults);
static void readAllProperties(std::shared_ptr< Opm::Deck > deck, RigEclipseCaseData* caseData, std::map<QString, QString>* newResults);
static void getAllValuesForKeyword(std::shared_ptr< Opm::Deck > deck, const std::string& keyword, std::vector<double>& allValues);
static bool isDataItemCountIdenticalToMainGridCellCount(std::shared_ptr< Opm::Deck > deck, const std::string& keyword, RigCaseData* caseData);
static bool isDataItemCountIdenticalToMainGridCellCount(std::shared_ptr< Opm::Deck > deck, const std::string& keyword, RigEclipseCaseData* caseData);
bool open(const QString& fileName);
private:

2
ApplicationCode/ModelVisualization/Intersections/RivIntersectionBoxPartMgr.cpp
View File

@ -94,7 +94,7 @@ void RivIntersectionBoxPartMgr::updateCellResultColor(size_t timeStepIndex)
CVF_ASSERT(cellResultColors);
RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(cellResultColors->porosityModel());
RigCaseData* eclipseCase = eclipseView->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = eclipseView->eclipseCase()->reservoirData();
// CrossSections
if (m_intersectionBoxFaces.notNull())

2
ApplicationCode/ModelVisualization/Intersections/RivIntersectionPartMgr.cpp
View File

@ -99,7 +99,7 @@ void RivIntersectionPartMgr::updateCellResultColor(size_t timeStepIndex)
CVF_ASSERT(cellResultColors);
RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(cellResultColors->porosityModel());
RigCaseData* eclipseCase = eclipseView->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = eclipseView->eclipseCase()->reservoirData();
// CrossSections
if (m_crossSectionFaces.notNull())

10
ApplicationCode/ModelVisualization/RivCellEdgeGeometryUtils.cpp
View File

@ -21,7 +21,7 @@
#include "RivCellEdgeGeometryUtils.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigCellEdgeResultAccessor.h"
#include "RigGridBase.h"
#include "RigResultAccessor.h"
@ -55,7 +55,7 @@ void RivCellEdgeGeometryUtils::addCellEdgeResultsToDrawableGeo(
bool useDefaultValueForHugeVals,
float opacityLevel)
{
RigCaseData* eclipseCase = cellResultColors->reservoirView()->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = cellResultColors->reservoirView()->eclipseCase()->reservoirData();
CVF_ASSERT(eclipseCase != NULL);
// Create result access objects
@ -199,7 +199,7 @@ void RivCellEdgeGeometryUtils::addTernaryCellEdgeResultsToDrawableGeo(size_t tim
const cvf::StructGridQuadToCellFaceMapper* quadToCellFaceMapper,
cvf::DrawableGeo* geo, size_t gridIndex, float opacityLevel)
{
RigCaseData* eclipseCase = cellResultColors->reservoirView()->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = cellResultColors->reservoirView()->eclipseCase()->reservoirData();
CVF_ASSERT(eclipseCase != NULL);
cvf::ref<RigResultAccessor> cellEdgeResultAccessor = createCellEdgeResultAccessor(cellResultColors, cellEdgeResultColors, timeStepIndex, eclipseCase, eclipseCase->grid(gridIndex));
@ -294,7 +294,7 @@ cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellEdgeResultAccess
RimEclipseCellColors* cellResultColors,
RimCellEdgeColors* cellEdgeResultColors,
size_t timeStepIndex,
RigCaseData* eclipseCase,
RigEclipseCaseData* eclipseCase,
const RigGridBase* grid)
{
cvf::ref<RigCellEdgeResultAccessor> cellEdgeResultAccessor = new RigCellEdgeResultAccessor();
@ -326,7 +326,7 @@ cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellEdgeResultAccess
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellCenterResultAccessor(RimEclipseCellColors* cellResultColors, size_t timeStepIndex, RigCaseData* eclipseCase, const RigGridBase* grid)
cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellCenterResultAccessor(RimEclipseCellColors* cellResultColors, size_t timeStepIndex, RigEclipseCaseData* eclipseCase, const RigGridBase* grid)
{
cvf::ref<RigResultAccessor> resultAccessor = NULL;

6
ApplicationCode/ModelVisualization/RivCellEdgeGeometryUtils.h
View File

@ -32,7 +32,7 @@ class RimCellEdgeColors;
class RimEclipseCellColors;
class RigGridBase;
class RigResultAccessor;
class RigCaseData;
class RigEclipseCaseData;
class RivCellEdgeGeometryUtils
@ -60,14 +60,14 @@ private:
static cvf::ref<RigResultAccessor> createCellCenterResultAccessor(
RimEclipseCellColors* cellResultColors,
size_t timeStepIndex,
RigCaseData* eclipseCase,
RigEclipseCaseData* eclipseCase,
const RigGridBase* grid);
static cvf::ref<RigResultAccessor> createCellEdgeResultAccessor(
RimEclipseCellColors* cellResultColors,
RimCellEdgeColors* cellEdgeResultColors,
size_t timeStepIndex,
RigCaseData* eclipseCase,
RigEclipseCaseData* eclipseCase,
const RigGridBase* grid);
static bool hideScalarValue(double scalarValue, double scalarValueToHide, double tolerance);

2
ApplicationCode/ModelVisualization/RivFaultPartMgr.cpp
View File

@ -103,7 +103,7 @@ void RivFaultPartMgr::updateCellResultColor(size_t timeStepIndex, RimEclipseCell
RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(cellResultColors->porosityModel());
RimEclipseView* eclipseView = cellResultColors->reservoirView();
RigCaseData* eclipseCase = eclipseView->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = eclipseView->eclipseCase()->reservoirData();
// Faults
if (m_nativeFaultFaces.notNull())

2
ApplicationCode/ModelVisualization/RivGridPartMgr.cpp
View File

@ -24,7 +24,7 @@
#include "RiaPreferences.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigResultAccessorFactory.h"
#include "RimCellEdgeColors.h"

4
ApplicationCode/ModelVisualization/RivReservoirPartMgr.cpp
View File

@ -20,7 +20,7 @@
#include "RivReservoirPartMgr.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RivGridPartMgr.h"
#include "RivReservoirFaultsPartMgr.h"
@ -30,7 +30,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivReservoirPartMgr::clearAndSetReservoir(const RigCaseData* eclipseCase, RimEclipseView* reservoirView)
void RivReservoirPartMgr::clearAndSetReservoir(const RigEclipseCaseData* eclipseCase, RimEclipseView* reservoirView)
{
m_allGrids.clear();

4
ApplicationCode/ModelVisualization/RivReservoirPartMgr.h
View File

@ -32,7 +32,7 @@ namespace cvf
class RimEclipseCellColors;
class RimCellEdgeColors;
class RigCaseData;
class RigEclipseCaseData;
class RimEclipseView;
class RivReservoirFaultsPartMgr;
class RivGridPartMgr;
@ -47,7 +47,7 @@ class RivGridPartMgr;
class RivReservoirPartMgr: public cvf::Object
{
public:
void clearAndSetReservoir(const RigCaseData* eclipseCase, RimEclipseView* reservoirView);
void clearAndSetReservoir(const RigEclipseCaseData* eclipseCase, RimEclipseView* reservoirView);
void setTransform(cvf::Transform* scaleTransform);
void setCellVisibility(size_t gridIndex, cvf::UByteArray* cellVisibilities );

14
ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.cpp
View File

@ -22,7 +22,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigCaseToCaseCellMapper.h"
#include "RigCell.h"
#include "RigGridBase.h"
@ -149,7 +149,7 @@ void RivReservoirViewPartMgr::scheduleGeometryRegen(RivCellSetEnum geometryType)
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::clearGeometryCache(RivCellSetEnum geomType)
{
RigCaseData* eclipseCase = NULL;
RigEclipseCaseData* eclipseCase = NULL;
if (m_reservoirView != NULL && m_reservoirView->eclipseCase())
{
eclipseCase = m_reservoirView->eclipseCase()->reservoirData();
@ -249,7 +249,7 @@ void RivReservoirViewPartMgr::appendDynamicGeometryPartsToModel(cvf::ModelBasicL
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::createGeometry(RivCellSetEnum geometryType)
{
RigCaseData* res = m_reservoirView->eclipseCase()->reservoirData();
RigEclipseCaseData* res = m_reservoirView->eclipseCase()->reservoirData();
m_geometries[geometryType].clearAndSetReservoir(res, m_reservoirView);
m_geometries[geometryType].setTransform(m_scaleTransform.p());
@ -272,7 +272,7 @@ void RivReservoirViewPartMgr::createGeometry(RivCellSetEnum geometryType)
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::computeVisibility(cvf::UByteArray* cellVisibility, RivCellSetEnum geometryType, RigGridBase* grid, size_t gridIdx)
{
RigCaseData* eclipseCase = m_reservoirView->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = m_reservoirView->eclipseCase()->reservoirData();
RigActiveCellInfo* activeCellInfo = m_reservoirView->currentActiveCellInfo();
switch (geometryType)
@ -399,7 +399,7 @@ void RivReservoirViewPartMgr::computeVisibility(cvf::UByteArray* cellVisibility,
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::createPropertyFilteredNoneWellCellGeometry(size_t frameIndex)
{
RigCaseData* res = m_reservoirView->eclipseCase()->reservoirData();
RigEclipseCaseData* res = m_reservoirView->eclipseCase()->reservoirData();
if ( frameIndex >= m_propFilteredGeometryFrames.size())
{
@ -476,7 +476,7 @@ void RivReservoirViewPartMgr::createPropertyFilteredNoneWellCellGeometry(size_t
//--------------------------------------------------------------------------------------------------
void RivReservoirViewPartMgr::createPropertyFilteredWellGeometry(size_t frameIndex)
{
RigCaseData* res = m_reservoirView->eclipseCase()->reservoirData();
RigEclipseCaseData* res = m_reservoirView->eclipseCase()->reservoirData();
if ( frameIndex >= m_propFilteredWellGeometryFrames.size())
{
@ -789,7 +789,7 @@ void RivReservoirViewPartMgr::computePropertyVisibility(cvf::UByteArray* cellVis
{
const RimCellFilter::FilterModeType filterType = propertyFilter->filterMode();
RigCaseData* eclipseCase = propFilterColl->reservoirView()->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = propFilterColl->reservoirView()->eclipseCase()->reservoirData();
cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromResultDefinition(eclipseCase, grid->gridIndex(), timeStepIndex, propertyFilter->resultDefinition);

2
ApplicationCode/ModelVisualization/RivSimWellPipesPartMgr.cpp
View File

@ -20,7 +20,7 @@
#include "RivSimWellPipesPartMgr.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigCell.h"
#include "RigMainGrid.h"
#include "RigSimulationWellCenterLineCalculator.h"

4
ApplicationCode/ModelVisualization/RivSingleCellPartGenerator.cpp
View File

@ -19,7 +19,7 @@
#include "RivSingleCellPartGenerator.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigFemPartCollection.h"
#include "RigGeoMechCaseData.h"
#include "RigGridBase.h"
@ -37,7 +37,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivSingleCellPartGenerator::RivSingleCellPartGenerator(RigCaseData* rigCaseData, size_t gridIndex, size_t cellIndex)
RivSingleCellPartGenerator::RivSingleCellPartGenerator(RigEclipseCaseData* rigCaseData, size_t gridIndex, size_t cellIndex)
: m_rigCaseData(rigCaseData),
m_gridIndex(gridIndex),
m_cellIndex(cellIndex),

6
ApplicationCode/ModelVisualization/RivSingleCellPartGenerator.h
View File

@ -27,7 +27,7 @@ namespace cvf
class Part;
}
class RigCaseData;
class RigEclipseCaseData;
class RimGeoMechCase;
//==================================================================================================
@ -37,7 +37,7 @@ class RimGeoMechCase;
class RivSingleCellPartGenerator
{
public:
RivSingleCellPartGenerator(RigCaseData* rigCaseData, size_t gridIndex, size_t cellIndex);
RivSingleCellPartGenerator(RigEclipseCaseData* rigCaseData, size_t gridIndex, size_t cellIndex);
RivSingleCellPartGenerator(RimGeoMechCase* rimGeoMechCase, size_t gridIndex, size_t cellIndex);
cvf::ref<cvf::Part> createPart(const cvf::Color3f color);
@ -46,7 +46,7 @@ private:
cvf::ref<cvf::DrawableGeo> createMeshDrawable();
private:
RigCaseData* m_rigCaseData;
RigEclipseCaseData* m_rigCaseData;
RimGeoMechCase* m_geoMechCase;
size_t m_gridIndex;
size_t m_cellIndex;

6
ApplicationCode/ModelVisualization/RivTernaryTextureCoordsCreator.cpp
View File

@ -20,7 +20,7 @@
#include "RivTernaryTextureCoordsCreator.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigPipeInCellEvaluator.h"
#include "RigResultAccessorFactory.h"
#include "RigTernaryResultAccessor2d.h"
@ -49,7 +49,7 @@ RivTernaryTextureCoordsCreator::RivTernaryTextureCoordsCreator(
CVF_ASSERT(quadMapper);
m_quadMapper = quadMapper;
RigCaseData* eclipseCase = cellResultColors->reservoirView()->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = cellResultColors->reservoirView()->eclipseCase()->reservoirData();
size_t resTimeStepIdx = timeStepIndex;
@ -83,7 +83,7 @@ RivTernaryTextureCoordsCreator::RivTernaryTextureCoordsCreator(
size_t timeStepIndex)
: m_quadMapper(NULL)
{
RigCaseData* eclipseCase = cellResultColors->reservoirView()->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = cellResultColors->reservoirView()->eclipseCase()->reservoirData();
size_t resTimeStepIdx = timeStepIndex;

4
ApplicationCode/ModelVisualization/RivTextureCoordsCreator.cpp
View File

@ -20,7 +20,7 @@
#include "RivTextureCoordsCreator.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigPipeInCellEvaluator.h"
#include "RigResultAccessorFactory.h"
@ -40,7 +40,7 @@
//--------------------------------------------------------------------------------------------------
RivTextureCoordsCreator::RivTextureCoordsCreator(RimEclipseCellColors* cellResultColors, size_t timeStepIndex, size_t gridIndex, const cvf::StructGridQuadToCellFaceMapper* quadMapper)
{
RigCaseData* eclipseCase = cellResultColors->reservoirView()->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = cellResultColors->reservoirView()->eclipseCase()->reservoirData();
m_quadMapper = quadMapper;
CVF_ASSERT(quadMapper && eclipseCase );

4
ApplicationCode/ModelVisualization/RivWellHeadPartMgr.cpp
View File

@ -25,7 +25,7 @@
#include "RiaApplication.h"
#include "RigActiveCellInfo.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigCell.h"
#include "RigMainGrid.h"
@ -87,7 +87,7 @@ void RivWellHeadPartMgr::buildWellHeadParts(size_t frameIndex)
if (m_rimReservoirView.isNull()) return;
RigCaseData* rigReservoir = m_rimReservoirView->eclipseCase()->reservoirData();
RigEclipseCaseData* rigReservoir = m_rimReservoirView->eclipseCase()->reservoirData();
RimEclipseWell* well = m_rimWell;

2
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@ -21,7 +21,7 @@
#include "Rim3dOverlayInfoConfig.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigEclipseNativeVisibleCellsStatCalc.h"
#include "RigFemNativeVisibleCellsStatCalc.h"
#include "RigFemPartCollection.h"

14
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -25,7 +25,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RimCaseCollection.h"
@ -120,7 +120,7 @@ RimEclipseCase::~RimEclipseCase()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigCaseData* RimEclipseCase::reservoirData()
RigEclipseCaseData* RimEclipseCase::reservoirData()
{
return m_rigEclipseCase.p();
}
@ -128,7 +128,7 @@ RigCaseData* RimEclipseCase::reservoirData()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigCaseData* RimEclipseCase::reservoirData() const
const RigEclipseCaseData* RimEclipseCase::reservoirData() const
{
return m_rigEclipseCase.p();
}
@ -294,7 +294,7 @@ void RimEclipseCase::fieldChangedByUi(const caf::PdmFieldHandle* changedField, c
}
else if (changedField == &flipXAxis || changedField == &flipYAxis)
{
RigCaseData* rigEclipseCase = reservoirData();
RigEclipseCaseData* rigEclipseCase = reservoirData();
if (rigEclipseCase)
{
rigEclipseCase->mainGrid()->setFlipAxis(flipXAxis, flipYAxis);
@ -323,7 +323,7 @@ void RimEclipseCase::fieldChangedByUi(const caf::PdmFieldHandle* changedField, c
//--------------------------------------------------------------------------------------------------
void RimEclipseCase::updateFormationNamesData()
{
RigCaseData* rigEclipseCase = reservoirData();
RigEclipseCaseData* rigEclipseCase = reservoirData();
if(rigEclipseCase)
{
if(activeFormationNames())
@ -381,7 +381,7 @@ void RimEclipseCase::updateFormationNamesData()
//--------------------------------------------------------------------------------------------------
void RimEclipseCase::computeCachedData()
{
RigCaseData* rigEclipseCase = reservoirData();
RigEclipseCaseData* rigEclipseCase = reservoirData();
if (rigEclipseCase)
{
caf::ProgressInfo pInf(30, "");
@ -425,7 +425,7 @@ RimCaseCollection* RimEclipseCase::parentCaseCollection()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseCase::setReservoirData(RigCaseData* eclipseCase)
void RimEclipseCase::setReservoirData(RigEclipseCaseData* eclipseCase)
{
m_rigEclipseCase = eclipseCase;
if (this->reservoirData())

10
ApplicationCode/ProjectDataModel/RimEclipseCase.h
View File

@ -36,7 +36,7 @@
class QString;
class RigCaseData;
class RigEclipseCaseData;
class RigGridBase;
class RimCaseCollection;
class RimIdenticalGridCaseGroup;
@ -68,8 +68,8 @@ public:
bool openReserviorCase();
virtual bool openEclipseGridFile() = 0;
RigCaseData* reservoirData();
const RigCaseData* reservoirData() const;
RigEclipseCaseData* reservoirData();
const RigEclipseCaseData* reservoirData() const;
RimReservoirCellResultsStorage* results(RifReaderInterface::PorosityModelResultType porosityModel);
@ -104,10 +104,10 @@ protected:
// Internal methods
protected:
void computeCachedData();
void setReservoirData(RigCaseData* eclipseCase);
void setReservoirData(RigEclipseCaseData* eclipseCase);
private:
cvf::ref<RigCaseData> m_rigEclipseCase;
cvf::ref<RigEclipseCaseData> m_rigEclipseCase;
private:
caf::PdmChildField<RimReservoirCellResultsStorage*> m_matrixModelResults;

10
ApplicationCode/ProjectDataModel/RimEclipseCaseCollection.cpp
View File

@ -22,7 +22,7 @@
#include "RiaApplication.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigGridManager.h"
#include "RigMainGrid.h"
@ -76,7 +76,7 @@ RimIdenticalGridCaseGroup* RimEclipseCaseCollection::createIdenticalCaseGroupFro
{
CVF_ASSERT(mainCase);
RigCaseData* rigEclipseCase = mainCase->reservoirData();
RigEclipseCaseData* rigEclipseCase = mainCase->reservoirData();
RigMainGrid* equalGrid = registerCaseInGridCollection(rigEclipseCase);
CVF_ASSERT(equalGrid);
@ -101,7 +101,7 @@ void RimEclipseCaseCollection::moveEclipseCaseIntoCaseGroup(RimEclipseCase* rimR
{
CVF_ASSERT(rimReservoir);
RigCaseData* rigEclipseCase = rimReservoir->reservoirData();
RigEclipseCaseData* rigEclipseCase = rimReservoir->reservoirData();
RigMainGrid* equalGrid = registerCaseInGridCollection(rigEclipseCase);
CVF_ASSERT(equalGrid);
@ -155,7 +155,7 @@ void RimEclipseCaseCollection::removeCaseFromAllGroups(RimEclipseCase* reservoir
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigMainGrid* RimEclipseCaseCollection::registerCaseInGridCollection(RigCaseData* rigEclipseCase)
RigMainGrid* RimEclipseCaseCollection::registerCaseInGridCollection(RigEclipseCaseData* rigEclipseCase)
{
CVF_ASSERT(rigEclipseCase);
@ -188,7 +188,7 @@ void RimEclipseCaseCollection::insertCaseInCaseGroup(RimIdenticalGridCaseGroup*
{
CVF_ASSERT(rimReservoir);
RigCaseData* rigEclipseCase = rimReservoir->reservoirData();
RigEclipseCaseData* rigEclipseCase = rimReservoir->reservoirData();
registerCaseInGridCollection(rigEclipseCase);
caseGroup->addCase(rimReservoir);

4
ApplicationCode/ProjectDataModel/RimEclipseCaseCollection.h
View File

@ -27,7 +27,7 @@
#include "cvfObject.h"
class RigCaseData;
class RigEclipseCaseData;
class RigGridManager;
class RigMainGrid;
class RimEclipseCase;
@ -59,6 +59,6 @@ public:
void recomputeStatisticsForAllCaseGroups();
private:
RigMainGrid* registerCaseInGridCollection(RigCaseData* rigEclipseCase);
RigMainGrid* registerCaseInGridCollection(RigEclipseCaseData* rigEclipseCase);
cvf::ref<RigGridManager> m_gridCollection;
};

8
ApplicationCode/ProjectDataModel/RimEclipseInputCase.cpp
View File

@ -30,7 +30,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RimDefines.h"
@ -96,7 +96,7 @@ void RimEclipseInputCase::openDataFileSet(const QStringList& fileNames)
if (this->reservoirData() == NULL)
{
this->setReservoirData(new RigCaseData);
this->setReservoirData(new RigEclipseCaseData);
}
// First find and read the grid data
@ -193,7 +193,7 @@ bool RimEclipseInputCase::openEclipseGridFile()
readerInterface = new RifReaderEclipseInput;
readerInterface->setReaderSetting(prefs->readerSettings());
cvf::ref<RigCaseData> eclipseCase = new RigCaseData;
cvf::ref<RigEclipseCaseData> eclipseCase = new RigEclipseCaseData;
if (!readerInterface->open(m_gridFileName, eclipseCase.p()))
{
return false;
@ -335,7 +335,7 @@ void RimEclipseInputCase::loadAndSyncronizeInputProperties()
//--------------------------------------------------------------------------------------------------
cvf::ref<RifReaderInterface> RimEclipseInputCase::createMockModel(QString modelName)
{
cvf::ref<RigCaseData> reservoir = new RigCaseData;
cvf::ref<RigEclipseCaseData> reservoir = new RigEclipseCaseData;
cvf::ref<RifReaderMockModel> mockFileInterface = new RifReaderMockModel;
if (modelName == RimDefines::mockModelBasicInputCase())

4
ApplicationCode/ProjectDataModel/RimEclipseInputCaseOpm.cpp
View File

@ -25,7 +25,7 @@
#include "RifReaderSettings.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RimEclipseCase.h"
@ -162,7 +162,7 @@ void RimEclipseInputCaseOpm::importEclipseGridAndProperties(const QString& fileN
{
if (this->reservoirData() == NULL)
{
this->setReservoirData(new RigCaseData);
this->setReservoirData(new RigEclipseCaseData);
RifReaderOpmParserInput::importGridPropertiesFaults(fileName, reservoirData());

2
ApplicationCode/ProjectDataModel/RimEclipseInputProperty.cpp
View File

@ -21,7 +21,7 @@
#include "RimEclipseInputProperty.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RimEclipseInputCase.h"
#include "RimEclipseResultDefinition.h"

2
ApplicationCode/ProjectDataModel/RimEclipsePropertyFilter.cpp
View File

@ -21,7 +21,7 @@
#include "RimEclipsePropertyFilter.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigFormationNames.h"
#include "RimEclipseCase.h"

10
ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

@ -28,7 +28,7 @@
#include "RifReaderSettings.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RimMockModelSettings.h"
@ -110,7 +110,7 @@ bool RimEclipseResultCase::openEclipseGridFile()
readerInterface->setReaderSetting(prefs->readerSettings());
readerInterface->setFilenamesWithFaults(this->filesContainingFaults());
cvf::ref<RigCaseData> eclipseCase = new RigCaseData;
cvf::ref<RigEclipseCaseData> eclipseCase = new RigEclipseCaseData;
if (!readerInterface->open(caseFileName(), eclipseCase.p()))
{
return false;
@ -141,7 +141,7 @@ bool RimEclipseResultCase::openEclipseGridFile()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipseResultCase::openAndReadActiveCellData(RigCaseData* mainEclipseCase)
bool RimEclipseResultCase::openAndReadActiveCellData(RigEclipseCaseData* mainEclipseCase)
{
// Early exit if data is already read
if (m_activeCellInfoIsReadFromFile) return true;
@ -158,7 +158,7 @@ bool RimEclipseResultCase::openAndReadActiveCellData(RigCaseData* mainEclipseCas
return false;
}
cvf::ref<RigCaseData> eclipseCase = new RigCaseData;
cvf::ref<RigEclipseCaseData> eclipseCase = new RigEclipseCaseData;
CVF_ASSERT(mainEclipseCase && mainEclipseCase->mainGrid());
eclipseCase->setMainGrid(mainEclipseCase->mainGrid());
@ -204,7 +204,7 @@ bool RimEclipseResultCase::openAndReadActiveCellData(RigCaseData* mainEclipseCas
cvf::ref<RifReaderInterface> RimEclipseResultCase::createMockModel(QString modelName)
{
cvf::ref<RifReaderMockModel> mockFileInterface = new RifReaderMockModel;
cvf::ref<RigCaseData> reservoir = new RigCaseData;
cvf::ref<RigEclipseCaseData> reservoir = new RigEclipseCaseData;
if (modelName == RimDefines::mockModelBasic())
{

2
ApplicationCode/ProjectDataModel/RimEclipseResultCase.h
View File

@ -44,7 +44,7 @@ public:
void setCaseInfo(const QString& userDescription, const QString& caseFileName);
virtual bool openEclipseGridFile();
bool openAndReadActiveCellData(RigCaseData* mainEclipseCase);
bool openAndReadActiveCellData(RigEclipseCaseData* mainEclipseCase);
void readGridDimensions(std::vector< std::vector<int> >& gridDimensions);
// Overrides from RimCase

2
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@ -22,7 +22,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RimCellEdgeColors.h"
#include "RimEclipseCase.h"

10
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
View File

@ -23,7 +23,7 @@
#include "RicNewViewFeature.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigSingleWellResultsData.h"
#include "RimCaseCollection.h"
@ -143,7 +143,7 @@ bool RimEclipseStatisticsCase::openEclipseGridFile()
{
if (this->reservoirData()) return true;
cvf::ref<RigCaseData> eclipseCase = new RigCaseData;
cvf::ref<RigEclipseCaseData> eclipseCase = new RigEclipseCaseData;
CVF_ASSERT(parentStatisticsCaseCollection());
@ -228,7 +228,7 @@ void RimEclipseStatisticsCase::computeStatistics()
timeStepIndices.push_back(i);
}
RigCaseData* resultCase = reservoirData();
RigEclipseCaseData* resultCase = reservoirData();
QList<RimEclipseStatisticsCaseEvaluator::ResSpec > resultSpecification;
@ -395,7 +395,7 @@ QList<caf::PdmOptionItemInfo> RimEclipseStatisticsCase::calculateValueOptions(co
return options;
}
RigCaseData* caseData = idgcg->mainCase()->reservoirData();
RigEclipseCaseData* caseData = idgcg->mainCase()->reservoirData();
if (&m_selectedDynamicProperties == fieldNeedingOptions)
{
@ -716,7 +716,7 @@ void RimEclipseStatisticsCase::populateResultSelection()
return;
}
RigCaseData* caseData = idgcg->mainCase()->reservoirData();
RigEclipseCaseData* caseData = idgcg->mainCase()->reservoirData();
if (m_selectedDynamicProperties().size() == 0)
{

4
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp
View File

@ -21,7 +21,7 @@
#include "RimEclipseStatisticsCaseEvaluator.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RigResultAccessorFactory.h"
#include "RigResultModifier.h"
@ -317,7 +317,7 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>&
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseStatisticsCaseEvaluator::RimEclipseStatisticsCaseEvaluator(const std::vector<RimEclipseCase*>& sourceCases, const std::vector<size_t>& timeStepIndices, const RimStatisticsConfig& statisticsConfig, RigCaseData* destinationCase, RimIdenticalGridCaseGroup* identicalGridCaseGroup)
RimEclipseStatisticsCaseEvaluator::RimEclipseStatisticsCaseEvaluator(const std::vector<RimEclipseCase*>& sourceCases, const std::vector<size_t>& timeStepIndices, const RimStatisticsConfig& statisticsConfig, RigEclipseCaseData* destinationCase, RimIdenticalGridCaseGroup* identicalGridCaseGroup)
: m_sourceCases(sourceCases),
m_statisticsConfig(statisticsConfig),
m_destinationCase(destinationCase),

6
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.h
View File

@ -28,7 +28,7 @@
class RimEclipseCase;
class RigCaseData;
class RigEclipseCaseData;
class RigCaseCellResultsData;
@ -59,7 +59,7 @@ public:
RimEclipseStatisticsCaseEvaluator(const std::vector<RimEclipseCase*>& sourceCases,
const std::vector<size_t>& timeStepIndices,
const RimStatisticsConfig& statisticsConfig,
RigCaseData* destinationCase,
RigEclipseCaseData* destinationCase,
RimIdenticalGridCaseGroup* identicalGridCaseGroup);
struct ResSpec
@ -90,7 +90,7 @@ private:
size_t m_reservoirCellCount;
RimStatisticsConfig m_statisticsConfig;
RigCaseData* m_destinationCase;
RigEclipseCaseData* m_destinationCase;
RimIdenticalGridCaseGroup* m_identicalGridCaseGroup;
bool m_useZeroAsInactiveCellValue;
};

4
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -25,7 +25,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigFlowDiagResults.h"
#include "RigFormationNames.h"
#include "RigMainGrid.h"
@ -944,7 +944,7 @@ void RimEclipseView::updateLegends()
return;
}
RigCaseData* eclipseCase = m_reservoir->reservoirData();
RigEclipseCaseData* eclipseCase = m_reservoir->reservoirData();
CVF_ASSERT(eclipseCase);
RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(cellResult()->porosityModel());

2
ApplicationCode/ProjectDataModel/RimFlowDiagSolution.cpp
View File

@ -22,7 +22,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigFlowDiagResults.h"
#include "RigMainGrid.h"
#include "RigSingleWellResultsData.h"

4
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@ -23,7 +23,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigGridManager.h"
#include "RigMainGrid.h"
@ -181,7 +181,7 @@ void RimIdenticalGridCaseGroup::loadMainCaseAndActiveCellInfo()
return;
}
RigCaseData* rigCaseData = mainCase->reservoirData();
RigEclipseCaseData* rigCaseData = mainCase->reservoirData();
CVF_ASSERT(rigCaseData);
RifReaderInterface::PorosityModelResultType poroModel = RifReaderInterface::MATRIX_RESULTS;

2
ApplicationCode/ProjectDataModel/RimProject.cpp
View File

@ -23,7 +23,7 @@
#include "RiaApplication.h"
#include "RiaVersionInfo.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigGridBase.h"
#include "RimCalcScript.h"

2
ApplicationCode/ProjectDataModel/RimProject.h
View File

@ -26,7 +26,7 @@
#include <vector>
class RigCaseData;
class RigEclipseCaseData;
class RigGridManager;
class RigMainGrid;

10
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp
View File

@ -21,7 +21,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigCell.h"
#include "RigMainGrid.h"
@ -1518,17 +1518,17 @@ double RimReservoirCellResultsStorage::darchysValue()
if (rimCase && rimCase->reservoirData())
{
RigCaseData::UnitsType unitsType = rimCase->reservoirData()->unitsType();
RigEclipseCaseData::UnitsType unitsType = rimCase->reservoirData()->unitsType();
if (unitsType == RigCaseData::UNITS_FIELD)
if (unitsType == RigEclipseCaseData::UNITS_FIELD)
{
darchy = 0.001127;
}
else if (unitsType == RigCaseData::UNITS_METRIC)
else if (unitsType == RigEclipseCaseData::UNITS_METRIC)
{
darchy = 0.008527;
}
else if (unitsType == RigCaseData::UNITS_LAB)
else if (unitsType == RigEclipseCaseData::UNITS_LAB)
{
darchy = 3.6;
}

6
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@ -22,7 +22,7 @@
#include "RiaApplication.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigEclipseWellLogExtractor.h"
#include "RigFemPartResultsCollection.h"
#include "RigGeoMechCaseData.h"
@ -260,8 +260,8 @@ void RimWellLogExtractionCurve::onLoadDataAndUpdate()
eclExtractor->curveData(resAcc.p(), &values);
}
RigCaseData::UnitsType eclipseUnitsType = eclipseCase->reservoirData()->unitsType();
if (eclipseUnitsType == RigCaseData::UNITS_FIELD)
RigEclipseCaseData::UnitsType eclipseUnitsType = eclipseCase->reservoirData()->unitsType();
if (eclipseUnitsType == RigEclipseCaseData::UNITS_FIELD)
{
// See https://github.com/OPM/ResInsight/issues/538

4
ApplicationCode/ProjectDataModel/RimWellLogPlotCollection.cpp
View File

@ -62,7 +62,7 @@ RigEclipseWellLogExtractor* RimWellLogPlotCollection::findOrCreateExtractor(RimW
return NULL;
}
RigCaseData* eclCaseData = eclCase->reservoirData();
RigEclipseCaseData* eclCaseData = eclCase->reservoirData();
RigWellPath* wellPathGeom = wellPath->wellPathGeometry();
for (size_t exIdx = 0; exIdx < m_extractors.size(); ++exIdx)
{
@ -131,7 +131,7 @@ void RimWellLogPlotCollection::removeExtractors(const RigWellPath* wellPath)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogPlotCollection::removeExtractors(const RigCaseData* caseData)
void RimWellLogPlotCollection::removeExtractors(const RigEclipseCaseData* caseData)
{
for (int eIdx = (int) m_extractors.size() - 1; eIdx >= 0; eIdx--)
{

4
ApplicationCode/ProjectDataModel/RimWellLogPlotCollection.h
View File

@ -28,7 +28,7 @@ class RimWellLogPlot;
class RigEclipseWellLogExtractor;
class RigGeoMechWellLogExtractor;
class RimGeoMechCase;
class RigCaseData;
class RigEclipseCaseData;
class RigGeoMechCaseData;
class RigWellPath;
class RimWellPath;
@ -50,7 +50,7 @@ public:
RigGeoMechWellLogExtractor* findOrCreateExtractor(RimWellPath* wellPath, RimGeoMechCase* eclCase);
void removeExtractors(const RigWellPath* wellPath);
void removeExtractors(const RigCaseData* caseData);
void removeExtractors(const RigEclipseCaseData* caseData);
void removeExtractors(const RigGeoMechCaseData* caseData);
caf::PdmChildArrayField<RimWellLogPlot*> wellLogPlots;

4
ApplicationCode/ReservoirDataModel/CMakeLists_files.cmake
View File

@ -7,7 +7,7 @@ endif()
set (SOURCE_GROUP_HEADER_FILES
${CEE_CURRENT_LIST_DIR}RigActiveCellInfo.h
${CEE_CURRENT_LIST_DIR}RigCell.h
${CEE_CURRENT_LIST_DIR}RigCaseData.h
${CEE_CURRENT_LIST_DIR}RigEclipseCaseData.h
${CEE_CURRENT_LIST_DIR}RigGridBase.h
${CEE_CURRENT_LIST_DIR}RigGridManager.h
${CEE_CURRENT_LIST_DIR}RigResultAccessor.h
@ -54,7 +54,7 @@ ${CEE_CURRENT_LIST_DIR}RigLasFileExporter.h
set (SOURCE_GROUP_SOURCE_FILES
${CEE_CURRENT_LIST_DIR}RigActiveCellInfo.cpp
${CEE_CURRENT_LIST_DIR}RigCell.cpp
${CEE_CURRENT_LIST_DIR}RigCaseData.cpp
${CEE_CURRENT_LIST_DIR}RigEclipseCaseData.cpp
${CEE_CURRENT_LIST_DIR}RigGridBase.cpp
${CEE_CURRENT_LIST_DIR}RigGridManager.cpp
${CEE_CURRENT_LIST_DIR}RigResultAccessor.cpp

54
ApplicationCode/ReservoirDataModel/RigCaseData.cpp → ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
View File

@ -18,7 +18,7 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
@ -32,7 +32,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigCaseData::RigCaseData()
RigEclipseCaseData::RigEclipseCaseData()
{
m_mainGrid = new RigMainGrid();
@ -51,7 +51,7 @@ RigCaseData::RigCaseData()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigCaseData::~RigCaseData()
RigEclipseCaseData::~RigEclipseCaseData()
{
}
@ -59,7 +59,7 @@ RigCaseData::~RigCaseData()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigMainGrid* RigCaseData::mainGrid()
RigMainGrid* RigEclipseCaseData::mainGrid()
{
return m_mainGrid.p();
}
@ -67,7 +67,7 @@ RigMainGrid* RigCaseData::mainGrid()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigMainGrid* RigCaseData::mainGrid() const
const RigMainGrid* RigEclipseCaseData::mainGrid() const
{
return m_mainGrid.p();
}
@ -75,7 +75,7 @@ const RigMainGrid* RigCaseData::mainGrid() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseData::setMainGrid(RigMainGrid* mainGrid)
void RigEclipseCaseData::setMainGrid(RigMainGrid* mainGrid)
{
m_mainGrid = mainGrid;
@ -86,7 +86,7 @@ void RigCaseData::setMainGrid(RigMainGrid* mainGrid)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseData::allGrids(std::vector<RigGridBase*>* grids)
void RigEclipseCaseData::allGrids(std::vector<RigGridBase*>* grids)
{
CVF_ASSERT(grids);
@ -105,7 +105,7 @@ void RigCaseData::allGrids(std::vector<RigGridBase*>* grids)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseData::allGrids(std::vector<const RigGridBase*>* grids) const
void RigEclipseCaseData::allGrids(std::vector<const RigGridBase*>* grids) const
{
CVF_ASSERT(grids);
@ -124,7 +124,7 @@ void RigCaseData::allGrids(std::vector<const RigGridBase*>* grids) const
//--------------------------------------------------------------------------------------------------
/// Get grid by index. The main grid has index 0, so the first lgr has index 1
//--------------------------------------------------------------------------------------------------
const RigGridBase* RigCaseData::grid(size_t index) const
const RigGridBase* RigEclipseCaseData::grid(size_t index) const
{
CVF_ASSERT(m_mainGrid.notNull());
return m_mainGrid->gridByIndex(index);
@ -134,7 +134,7 @@ const RigGridBase* RigCaseData::grid(size_t index) const
//--------------------------------------------------------------------------------------------------
/// Get grid by index. The main grid has index 0, so the first lgr has index 1
//--------------------------------------------------------------------------------------------------
RigGridBase* RigCaseData::grid(size_t index)
RigGridBase* RigEclipseCaseData::grid(size_t index)
{
CVF_ASSERT(m_mainGrid.notNull());
return m_mainGrid->gridByIndex(index);
@ -143,7 +143,7 @@ RigGridBase* RigCaseData::grid(size_t index)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigCaseData::gridCount() const
size_t RigEclipseCaseData::gridCount() const
{
CVF_ASSERT(m_mainGrid.notNull());
return m_mainGrid->gridCount();
@ -153,7 +153,7 @@ size_t RigCaseData::gridCount() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseData::computeWellCellsPrGrid()
void RigEclipseCaseData::computeWellCellsPrGrid()
{
// If we have computed this already, return
if (m_wellCellsInGrid.size()) return;
@ -253,7 +253,7 @@ void RigCaseData::computeWellCellsPrGrid()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseData::setWellResults(const cvf::Collection<RigSingleWellResultsData>& data)
void RigEclipseCaseData::setWellResults(const cvf::Collection<RigSingleWellResultsData>& data)
{
m_wellResults = data;
m_wellCellsInGrid.clear();
@ -265,7 +265,7 @@ void RigCaseData::setWellResults(const cvf::Collection<RigSingleWellResultsData>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const cvf::UByteArray* RigCaseData::wellCellsInGrid(size_t gridIndex)
const cvf::UByteArray* RigEclipseCaseData::wellCellsInGrid(size_t gridIndex)
{
computeWellCellsPrGrid();
CVF_ASSERT(gridIndex < m_wellCellsInGrid.size());
@ -277,7 +277,7 @@ const cvf::UByteArray* RigCaseData::wellCellsInGrid(size_t gridIndex)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const cvf::UIntArray* RigCaseData::gridCellToResultWellIndex(size_t gridIndex)
const cvf::UIntArray* RigEclipseCaseData::gridCellToResultWellIndex(size_t gridIndex)
{
computeWellCellsPrGrid();
CVF_ASSERT(gridIndex < m_gridCellToResultWellIndex.size());
@ -288,7 +288,7 @@ const cvf::UIntArray* RigCaseData::gridCellToResultWellIndex(size_t gridIndex)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigCell& RigCaseData::cellFromWellResultCell(const RigWellResultPoint& wellResultCell)
RigCell& RigEclipseCaseData::cellFromWellResultCell(const RigWellResultPoint& wellResultCell)
{
CVF_ASSERT(wellResultCell.isCell());
@ -304,7 +304,7 @@ RigCell& RigCaseData::cellFromWellResultCell(const RigWellResultPoint& wellResul
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigCaseData::findSharedSourceFace(cvf::StructGridInterface::FaceType& sharedSourceFace,const RigWellResultPoint& sourceWellCellResult, const RigWellResultPoint& otherWellCellResult) const
bool RigEclipseCaseData::findSharedSourceFace(cvf::StructGridInterface::FaceType& sharedSourceFace,const RigWellResultPoint& sourceWellCellResult, const RigWellResultPoint& otherWellCellResult) const
{
size_t gridIndex = sourceWellCellResult.m_gridIndex;
size_t gridCellIndex = sourceWellCellResult.m_gridCellIndex;
@ -380,7 +380,7 @@ public:
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseData::computeActiveCellIJKBBox()
void RigEclipseCaseData::computeActiveCellIJKBBox()
{
if (m_mainGrid.notNull() && m_activeCellInfo.notNull() && m_fractureActiveCellInfo.notNull())
{
@ -411,7 +411,7 @@ void RigCaseData::computeActiveCellIJKBBox()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseData::computeActiveCellBoundingBoxes()
void RigEclipseCaseData::computeActiveCellBoundingBoxes()
{
computeActiveCellIJKBBox();
computeActiveCellsGeometryBoundingBox();
@ -420,7 +420,7 @@ void RigCaseData::computeActiveCellBoundingBoxes()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigActiveCellInfo* RigCaseData::activeCellInfo(RifReaderInterface::PorosityModelResultType porosityModel)
RigActiveCellInfo* RigEclipseCaseData::activeCellInfo(RifReaderInterface::PorosityModelResultType porosityModel)
{
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
{
@ -433,7 +433,7 @@ RigActiveCellInfo* RigCaseData::activeCellInfo(RifReaderInterface::PorosityModel
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigActiveCellInfo* RigCaseData::activeCellInfo(RifReaderInterface::PorosityModelResultType porosityModel) const
const RigActiveCellInfo* RigEclipseCaseData::activeCellInfo(RifReaderInterface::PorosityModelResultType porosityModel) const
{
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
{
@ -446,7 +446,7 @@ const RigActiveCellInfo* RigCaseData::activeCellInfo(RifReaderInterface::Porosit
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseData::setActiveCellInfo(RifReaderInterface::PorosityModelResultType porosityModel, RigActiveCellInfo* activeCellInfo)
void RigEclipseCaseData::setActiveCellInfo(RifReaderInterface::PorosityModelResultType porosityModel, RigActiveCellInfo* activeCellInfo)
{
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
{
@ -464,7 +464,7 @@ void RigCaseData::setActiveCellInfo(RifReaderInterface::PorosityModelResultType
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseData::computeActiveCellsGeometryBoundingBox()
void RigEclipseCaseData::computeActiveCellsGeometryBoundingBox()
{
if (m_activeCellInfo.isNull() || m_fractureActiveCellInfo.isNull())
{
@ -518,7 +518,7 @@ void RigCaseData::computeActiveCellsGeometryBoundingBox()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseData::setActiveFormationNames(RigFormationNames* activeFormationNames)
void RigEclipseCaseData::setActiveFormationNames(RigFormationNames* activeFormationNames)
{
m_activeFormationNamesData = activeFormationNames;
@ -582,7 +582,7 @@ void RigCaseData::setActiveFormationNames(RigFormationNames* activeFormationName
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigFormationNames* RigCaseData::activeFormationNames()
RigFormationNames* RigEclipseCaseData::activeFormationNames()
{
return m_activeFormationNamesData.p();
}
@ -590,7 +590,7 @@ RigFormationNames* RigCaseData::activeFormationNames()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigCaseCellResultsData* RigCaseData::results(RifReaderInterface::PorosityModelResultType porosityModel)
RigCaseCellResultsData* RigEclipseCaseData::results(RifReaderInterface::PorosityModelResultType porosityModel)
{
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
{
@ -603,7 +603,7 @@ RigCaseCellResultsData* RigCaseData::results(RifReaderInterface::PorosityModelRe
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigCaseCellResultsData* RigCaseData::results(RifReaderInterface::PorosityModelResultType porosityModel) const
const RigCaseCellResultsData* RigEclipseCaseData::results(RifReaderInterface::PorosityModelResultType porosityModel) const
{
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
{

6
ApplicationCode/ReservoirDataModel/RigCaseData.h → ApplicationCode/ReservoirDataModel/RigEclipseCaseData.h
View File

@ -44,7 +44,7 @@ struct RigWellResultPoint;
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RigCaseData : public cvf::Object
class RigEclipseCaseData : public cvf::Object
{
public:
enum UnitsType
@ -55,8 +55,8 @@ public:
};
public:
RigCaseData();
~RigCaseData();
RigEclipseCaseData();
~RigEclipseCaseData();
RigMainGrid* mainGrid();
const RigMainGrid* mainGrid() const;

4
ApplicationCode/ReservoirDataModel/RigEclipseWellLogExtractor.cpp
View File

@ -19,7 +19,7 @@
#include "RigEclipseWellLogExtractor.h"
#include <map>
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigWellPath.h"
#include "RigResultAccessor.h"
#include "cvfBoundingBox.h"
@ -32,7 +32,7 @@
///
//==================================================================================================
RigEclipseWellLogExtractor::RigEclipseWellLogExtractor(const RigCaseData* aCase, const RigWellPath* wellpath, const std::string& wellCaseErrorMsgName)
RigEclipseWellLogExtractor::RigEclipseWellLogExtractor(const RigEclipseCaseData* aCase, const RigWellPath* wellpath, const std::string& wellCaseErrorMsgName)
: m_caseData(aCase), RigWellLogExtractor(wellpath, wellCaseErrorMsgName)
{
calculateIntersection();

8
ApplicationCode/ReservoirDataModel/RigEclipseWellLogExtractor.h
View File

@ -29,7 +29,7 @@
#include <vector>
#include "cvfStructGrid.h"
class RigCaseData;
class RigEclipseCaseData;
class RigWellPath;
class RigResultAccessor;
@ -43,14 +43,14 @@ namespace cvf {
class RigEclipseWellLogExtractor : public RigWellLogExtractor
{
public:
RigEclipseWellLogExtractor(const RigCaseData* aCase, const RigWellPath* wellpath, const std::string& wellCaseErrorMsgName);
RigEclipseWellLogExtractor(const RigEclipseCaseData* aCase, const RigWellPath* wellpath, const std::string& wellCaseErrorMsgName);
void curveData(const RigResultAccessor* resultAccessor, std::vector<double>* values );
const RigCaseData* caseData() { return m_caseData.p();}
const RigEclipseCaseData* caseData() { return m_caseData.p();}
protected:
void calculateIntersection();
std::vector<size_t> findCloseCells(const cvf::BoundingBox& bb);
cvf::cref<RigCaseData> m_caseData;
cvf::cref<RigEclipseCaseData> m_caseData;
};

2
ApplicationCode/ReservoirDataModel/RigFlowDiagResults.cpp
View File

@ -19,7 +19,7 @@
#include "RigFlowDiagResults.h"
#include "RigActiveCellInfo.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigFlowDiagSolverInterface.h"
#include "RigFlowDiagStatCalc.h"

2
ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp
View File

@ -23,7 +23,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigFlowDiagInterfaceTools.h"
#include "RimEclipseCase.h"

2
ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.h
View File

@ -49,7 +49,7 @@ private:
};
class RigCaseData;
class RigEclipseCaseData;
class RigOpmFldStaticData;
class RigFlowDiagSolverInterface : public cvf::Object

8
ApplicationCode/ReservoirDataModel/RigGridManager.cpp
View File

@ -17,14 +17,14 @@
/////////////////////////////////////////////////////////////////////////////////
#include "RigGridManager.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigGridManager::addCase(RigCaseData* eclipseCase)
void RigGridManager::addCase(RigEclipseCaseData* eclipseCase)
{
cvf::ref<CaseToGridMap> caseAndGrid = new CaseToGridMap(eclipseCase, eclipseCase->mainGrid());
m_caseToGrid.push_back(caseAndGrid.p());
@ -33,7 +33,7 @@ void RigGridManager::addCase(RigCaseData* eclipseCase)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigGridManager::removeCase(RigCaseData* eclipseCase)
void RigGridManager::removeCase(RigEclipseCaseData* eclipseCase)
{
for (size_t i = 0; i < m_caseToGrid.size(); i++)
{
@ -121,7 +121,7 @@ bool RigGridManager::isGridDimensionsEqual(const std::vector< std::vector<int> >
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigGridManager::CaseToGridMap::CaseToGridMap(RigCaseData* eclipseCase, RigMainGrid* mainGrid) :
RigGridManager::CaseToGridMap::CaseToGridMap(RigEclipseCaseData* eclipseCase, RigMainGrid* mainGrid) :
m_eclipseCase(eclipseCase),
m_mainGrid(mainGrid)
{

10
ApplicationCode/ReservoirDataModel/RigGridManager.h
View File

@ -25,14 +25,14 @@
#include <vector>
class RigMainGrid;
class RigCaseData;
class RigEclipseCaseData;
class RigGridManager : public cvf::Object
{
public:
void addCase(RigCaseData* eclipseCase);
void addCase(RigEclipseCaseData* eclipseCase);
void removeCase(RigCaseData* eclipseCase);
void removeCase(RigEclipseCaseData* eclipseCase);
RigMainGrid* findEqualGrid(RigMainGrid* candidateGrid);
@ -44,9 +44,9 @@ private:
class CaseToGridMap : public cvf::Object
{
public:
CaseToGridMap(RigCaseData* eclipseCase, RigMainGrid* mainGrid);
CaseToGridMap(RigEclipseCaseData* eclipseCase, RigMainGrid* mainGrid);
RigCaseData* m_eclipseCase;
RigEclipseCaseData* m_eclipseCase;
RigMainGrid* m_mainGrid;
};

14
ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
View File

@ -21,7 +21,7 @@
#include "RigReservoirBuilderMock.h"
#include "RigActiveCellInfo.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigCell.h"
#include "RigMainGrid.h"
#include "RigSingleWellResultsData.h"
@ -168,7 +168,7 @@ void RigReservoirBuilderMock::appendCells(size_t nodeStartIndex, size_t cellCoun
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::populateReservoir(RigCaseData* eclipseCase)
void RigReservoirBuilderMock::populateReservoir(RigEclipseCaseData* eclipseCase)
{
std::vector<cvf::Vec3d>& mainGridNodes = eclipseCase->mainGrid()->nodes();
appendNodes(m_minWorldCoordinate, m_maxWorldCoordinate, cellDimension(), mainGridNodes);
@ -293,7 +293,7 @@ void RigReservoirBuilderMock::setWorldCoordinates(cvf::Vec3d minWorldCoordinate,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigReservoirBuilderMock::inputProperty(RigCaseData* eclipseCase, const QString& propertyName, std::vector<double>* values)
bool RigReservoirBuilderMock::inputProperty(RigEclipseCaseData* eclipseCase, const QString& propertyName, std::vector<double>* values)
{
size_t k;
@ -314,7 +314,7 @@ bool RigReservoirBuilderMock::inputProperty(RigCaseData* eclipseCase, const QStr
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigReservoirBuilderMock::staticResult(RigCaseData* eclipseCase, const QString& result, std::vector<double>* values)
bool RigReservoirBuilderMock::staticResult(RigEclipseCaseData* eclipseCase, const QString& result, std::vector<double>* values)
{
values->resize(eclipseCase->mainGrid()->globalCellArray().size());
@ -330,7 +330,7 @@ bool RigReservoirBuilderMock::staticResult(RigCaseData* eclipseCase, const QStri
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigReservoirBuilderMock::dynamicResult(RigCaseData* eclipseCase, const QString& result, size_t stepIndex, std::vector<double>* values)
bool RigReservoirBuilderMock::dynamicResult(RigEclipseCaseData* eclipseCase, const QString& result, size_t stepIndex, std::vector<double>* values)
{
int resultIndex = 1;
@ -365,7 +365,7 @@ bool RigReservoirBuilderMock::dynamicResult(RigCaseData* eclipseCase, const QStr
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::addWellData(RigCaseData* eclipseCase, RigGridBase* grid)
void RigReservoirBuilderMock::addWellData(RigEclipseCaseData* eclipseCase, RigGridBase* grid)
{
CVF_ASSERT(eclipseCase);
CVF_ASSERT(grid);
@ -481,7 +481,7 @@ void RigReservoirBuilderMock::addWellData(RigCaseData* eclipseCase, RigGridBase*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirBuilderMock::addFaults(RigCaseData* eclipseCase)
void RigReservoirBuilderMock::addFaults(RigEclipseCaseData* eclipseCase)
{
if (!eclipseCase) return;

18
ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.h
View File

@ -25,11 +25,7 @@
#include "cvfArray.h"
#include "cvfVector3.h"
//#include "RigCell.h"
//#include "RigCaseData.h"
//#include "RigMainGrid.h"
class RigCaseData;
class RigEclipseCaseData;
class RigMainGrid;
class RigConnection;
class RigGridBase;
@ -68,17 +64,17 @@ public:
void addLocalGridRefinement(const cvf::Vec3st& minCellPosition, const cvf::Vec3st& maxCellPosition, const cvf::Vec3st& singleCellRefinementFactors);
void populateReservoir(RigCaseData* eclipseCase);
void populateReservoir(RigEclipseCaseData* eclipseCase);
bool inputProperty(RigCaseData* eclipseCase, const QString& propertyName, std::vector<double>* values );
bool staticResult(RigCaseData* eclipseCase, const QString& result, std::vector<double>* values );
bool dynamicResult(RigCaseData* eclipseCase, const QString& result, size_t stepIndex, std::vector<double>* values );
bool inputProperty(RigEclipseCaseData* eclipseCase, const QString& propertyName, std::vector<double>* values );
bool staticResult(RigEclipseCaseData* eclipseCase, const QString& result, std::vector<double>* values );
bool dynamicResult(RigEclipseCaseData* eclipseCase, const QString& result, size_t stepIndex, std::vector<double>* values );
private:
void addFaults(RigCaseData* eclipseCase);
void addFaults(RigEclipseCaseData* eclipseCase);
static void addNnc(RigMainGrid* grid, size_t i1, size_t j1, size_t k1, size_t i2, size_t j2, size_t k2, std::vector<RigConnection> &nncConnections);
void addWellData(RigCaseData* eclipseCase, RigGridBase* grid);
void addWellData(RigEclipseCaseData* eclipseCase, RigGridBase* grid);
static void appendCells(size_t nodeStartIndex, size_t cellCount, RigGridBase* hostGrid, std::vector<RigCell>& cells);
static void appendNodes(const cvf::Vec3d& min, const cvf::Vec3d& max, const cvf::Vec3st& cubeDimension, std::vector<cvf::Vec3d>& nodes);

12
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.cpp
View File

@ -23,7 +23,7 @@
#include "RigActiveCellsResultAccessor.h"
#include "RigAllGridCellsResultAccessor.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigCombMultResultAccessor.h"
#include "RigCombTransResultAccessor.h"
#include "RigGridBase.h"
@ -44,7 +44,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromUiResultName(RigCaseData* eclipseCase,
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromUiResultName(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
@ -137,7 +137,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromUiResultName(Rig
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromNameAndType(RigCaseData* eclipseCase,
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromNameAndType(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
@ -172,7 +172,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromNameAndType(RigC
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultDefinition(RigCaseData* eclipseCase,
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultDefinition(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
size_t timeStepIndex,
RimEclipseResultDefinition* resultDefinition)
@ -214,7 +214,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultDefinition
//--------------------------------------------------------------------------------------------------
/// This function must be harmonized with RigResultModifierFactory::createResultModifier()
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createNativeFromUiResultName(RigCaseData* eclipseCase,
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createNativeFromUiResultName(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
@ -242,7 +242,7 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createNativeFromUiResultNa
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultIdx(RigCaseData* eclipseCase,
cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultIdx(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,

10
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.h
View File

@ -33,20 +33,20 @@ class RigResultAccessorFactory
{
public:
static cvf::ref<RigResultAccessor>
createFromResultDefinition(RigCaseData* eclipseCase,
createFromResultDefinition(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
size_t timeStepIndex,
RimEclipseResultDefinition* resultDefinition);
static cvf::ref<RigResultAccessor>
createFromUiResultName(RigCaseData* eclipseCase,
createFromUiResultName(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
const QString& uiResultName);
static cvf::ref<RigResultAccessor>
createFromNameAndType(RigCaseData* eclipseCase,
createFromNameAndType(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
@ -54,7 +54,7 @@ public:
RimDefines::ResultCatType resultType);
static cvf::ref<RigResultAccessor>
createFromResultIdx(RigCaseData* eclipseCase,
createFromResultIdx(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
@ -62,7 +62,7 @@ public:
private:
static cvf::ref<RigResultAccessor>
createNativeFromUiResultName(RigCaseData* eclipseCase,
createNativeFromUiResultName(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,

6
ApplicationCode/ReservoirDataModel/RigResultModifierFactory.cpp
View File

@ -20,7 +20,7 @@
#include "RigResultModifierFactory.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigResultModifier.h"
#include <math.h>
@ -29,7 +29,7 @@
//--------------------------------------------------------------------------------------------------
/// This function must be harmonized with RigResultAccessorFactory::createNativeResultAccessor()
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigCaseData* eclipseCase,
cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
@ -51,7 +51,7 @@ cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigCa
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigCaseData* eclipseCase,
cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex, size_t scalarResultIndex)

6
ApplicationCode/ReservoirDataModel/RigResultModifierFactory.h
View File

@ -21,21 +21,21 @@
#include "RifReaderInterface.h"
class RigCaseData;
class RigEclipseCaseData;
class RigResultModifier;
class RigResultModifierFactory
{
public:
static cvf::ref<RigResultModifier>
createResultModifier(RigCaseData* eclipseCase,
createResultModifier(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,
QString& uiResultName);
static cvf::ref<RigResultModifier>
createResultModifier(RigCaseData* eclipseCase,
createResultModifier(RigEclipseCaseData* eclipseCase,
size_t gridIndex,
RifReaderInterface::PorosityModelResultType porosityModel,
size_t timeStepIndex,

4
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp
View File

@ -19,7 +19,7 @@
#include "RigSimulationWellCenterLineCalculator.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigCell.h"
#include "RimEclipseCase.h"
@ -39,7 +39,7 @@ void RigSimulationWellCenterLineCalculator::calculateWellPipeCenterline(RimEclip
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds)
{
bool isAutoDetectBranches = false;
RigCaseData* eclipseCaseData = NULL;
RigEclipseCaseData* eclipseCaseData = NULL;
RigSingleWellResultsData* wellResults = NULL;
{

4
ApplicationCode/ReservoirDataModel/RigTimeHistoryResultAccessor.cpp
View File

@ -20,7 +20,7 @@
#include "RigTimeHistoryResultAccessor.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigGridBase.h"
#include "RigResultAccessor.h"
#include "RigResultAccessorFactory.h"
@ -30,7 +30,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigTimeHistoryResultAccessor::RigTimeHistoryResultAccessor(RigCaseData* eclipseCaseData, size_t gridIndex, size_t cellIndex, size_t scalarResultIndex, RifReaderInterface::PorosityModelResultType porosityModel)
RigTimeHistoryResultAccessor::RigTimeHistoryResultAccessor(RigEclipseCaseData* eclipseCaseData, size_t gridIndex, size_t cellIndex, size_t scalarResultIndex, RifReaderInterface::PorosityModelResultType porosityModel)
: m_eclipseCaseData(eclipseCaseData),
m_gridIndex(gridIndex),
m_cellIndex(cellIndex),

6
ApplicationCode/ReservoirDataModel/RigTimeHistoryResultAccessor.h
View File

@ -22,13 +22,13 @@
#include "cvfStructGrid.h"
#include "RifReaderInterface.h"
class RigCaseData;
class RigEclipseCaseData;
class RigTimeHistoryResultAccessor
{
public:
RigTimeHistoryResultAccessor(RigCaseData* eclipseCaseData, size_t gridIndex, size_t cellIndex, size_t scalarResultIndex, RifReaderInterface::PorosityModelResultType porosityModel);
RigTimeHistoryResultAccessor(RigEclipseCaseData* eclipseCaseData, size_t gridIndex, size_t cellIndex, size_t scalarResultIndex, RifReaderInterface::PorosityModelResultType porosityModel);
void setFace(cvf::StructGridInterface::FaceType face);
QString topologyText() const;
@ -38,7 +38,7 @@ private:
void computeTimeHistoryData();
private:
RigCaseData* m_eclipseCaseData;
RigEclipseCaseData* m_eclipseCaseData;
size_t m_gridIndex;
size_t m_cellIndex;

2
ApplicationCode/SocketInterface/RiaCaseInfoCommands.cpp
View File

@ -27,7 +27,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "Rim3dOverlayInfoConfig.h"

2
ApplicationCode/SocketInterface/RiaGeometryCommands.cpp
View File

@ -27,7 +27,7 @@
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "Rim3dOverlayInfoConfig.h"

2
ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp
View File

@ -24,7 +24,7 @@
#include "RiaSocketTools.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RigResultAccessor.h"
#include "RigResultAccessorFactory.h"

2
ApplicationCode/SocketInterface/RiaWellDataCommands.cpp
View File

@ -23,7 +23,7 @@
#include "RiaSocketTools.h"
#include "RigGridBase.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigSingleWellResultsData.h"
#include "RimEclipseCase.h"

2
ApplicationCode/UnitTests/RifEclipseInputFileTools-Test.cpp
View File

@ -1,6 +1,6 @@
#include "gtest/gtest.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RifEclipseInputFileTools.h"

4
ApplicationCode/UnitTests/RifReaderEclipseOutput-Test.cpp
View File

@ -20,7 +20,7 @@
#include "gtest/gtest.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include <ert/ecl/ecl_file.h>
@ -441,7 +441,7 @@ TEST(RigReservoirTest, BasicTest)
TEST(RigReservoirTest, WellTest)
{
cvf::ref<RifReaderEclipseOutput> readerInterfaceEcl = new RifReaderEclipseOutput;
cvf::ref<RigCaseData> reservoir = new RigCaseData;
cvf::ref<RigEclipseCaseData> reservoir = new RigEclipseCaseData;
// Location of test dataset received from Håkon Høgstøl in July 2011 with 10k active cells
#ifdef WIN32

6
ApplicationCode/UnitTests/RigReservoir-Test.cpp
View File

@ -20,7 +20,7 @@
#include "gtest/gtest.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigGridManager.h"
#include "RigMainGrid.h"
@ -32,7 +32,7 @@ TEST(RigGridManager, BasicTest)
{
cvf::ref<RigMainGrid> mainGridA = new RigMainGrid;
cvf::ref<RigCaseData> eclipseCase = new RigCaseData;
cvf::ref<RigEclipseCaseData> eclipseCase = new RigEclipseCaseData;
eclipseCase->setMainGrid(mainGridA.p());
int count = mainGridA->refCount();
@ -59,7 +59,7 @@ TEST(RigGridManager, EqualTests)
mainGridA->nodes().push_back(cvf::Vec3d(0, 0, 1));
mainGridA->nodes().push_back(cvf::Vec3d(0, 0, 2));
cvf::ref<RigCaseData> eclipseCase = new RigCaseData;
cvf::ref<RigEclipseCaseData> eclipseCase = new RigEclipseCaseData;
eclipseCase->setMainGrid(mainGridA.p());

2
ApplicationCode/UnitTests/opm-parser-Performance-Test.cpp
View File

@ -2,7 +2,7 @@
#include "opm/parser/eclipse/Parser/Parser.hpp"
#include "gtest/gtest.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RifEclipseInputFileTools.h"
#include "RifReaderOpmParserInput.h"

20
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

@ -20,7 +20,7 @@
#include "RiuResultTextBuilder.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigFormationNames.h"
#include "RigMainGrid.h"
#include "RigResultAccessor.h"
@ -139,7 +139,7 @@ QString RiuResultTextBuilder::topologyText(QString itemSeparator)
if (m_reservoirView && m_reservoirView->eclipseCase())
{
const RigCaseData* eclipseCase = m_reservoirView->eclipseCase()->reservoirData();
const RigEclipseCaseData* eclipseCase = m_reservoirView->eclipseCase()->reservoirData();
if (eclipseCase)
{
if (m_cellIndex != cvf::UNDEFINED_SIZE_T)
@ -187,7 +187,7 @@ QString RiuResultTextBuilder::gridResultDetails()
if (m_reservoirView->eclipseCase() && m_reservoirView->eclipseCase()->reservoirData())
{
RigCaseData* eclipseCaseData = m_reservoirView->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCaseData = m_reservoirView->eclipseCase()->reservoirData();
RigGridBase* grid = eclipseCaseData->grid(m_gridIndex);
this->appendTextFromResultColors(eclipseCaseData, m_gridIndex, m_cellIndex, m_timeStepIndex, m_reservoirView->cellResult(), &text);
@ -210,7 +210,7 @@ QString RiuResultTextBuilder::faultResultDetails()
if (m_reservoirView->eclipseCase() && m_reservoirView->eclipseCase()->reservoirData())
{
RigCaseData* eclipseCaseData = m_reservoirView->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCaseData = m_reservoirView->eclipseCase()->reservoirData();
RigGridBase* grid = eclipseCaseData->grid(m_gridIndex);
RigMainGrid* mainGrid = grid->mainGrid();
@ -251,7 +251,7 @@ QString RiuResultTextBuilder::formationDetails()
size_t k = cvf::UNDEFINED_SIZE_T;
{
const RigCaseData* eclipseData = m_reservoirView->eclipseCase()->reservoirData();
const RigEclipseCaseData* eclipseData = m_reservoirView->eclipseCase()->reservoirData();
if(eclipseData)
{
if(m_cellIndex != cvf::UNDEFINED_SIZE_T)
@ -301,7 +301,7 @@ QString RiuResultTextBuilder::faultResultText()
if (m_reservoirView->eclipseCase() && m_reservoirView->eclipseCase()->reservoirData())
{
RigCaseData* eclipseCaseData = m_reservoirView->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCaseData = m_reservoirView->eclipseCase()->reservoirData();
RigGridBase* grid = eclipseCaseData->grid(m_gridIndex);
RigMainGrid* mainGrid = grid->mainGrid();
@ -331,7 +331,7 @@ QString RiuResultTextBuilder::nncResultText()
{
if (m_reservoirView.notNull() && m_reservoirView->eclipseCase())
{
RigCaseData* eclipseCase = m_reservoirView->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = m_reservoirView->eclipseCase()->reservoirData();
RigMainGrid* grid = eclipseCase->mainGrid();
CVF_ASSERT(grid);
@ -366,7 +366,7 @@ QString RiuResultTextBuilder::nncResultText()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuResultTextBuilder::appendTextFromResultColors(RigCaseData* eclipseCase, size_t gridIndex, size_t cellIndex, size_t timeStepIndex, RimEclipseCellColors* resultColors, QString* resultInfoText)
void RiuResultTextBuilder::appendTextFromResultColors(RigEclipseCaseData* eclipseCase, size_t gridIndex, size_t cellIndex, size_t timeStepIndex, RimEclipseCellColors* resultColors, QString* resultInfoText)
{
if (!resultColors)
{
@ -561,7 +561,7 @@ QString RiuResultTextBuilder::nncDetails()
{
if (m_reservoirView.notNull() && m_reservoirView->eclipseCase())
{
RigCaseData* eclipseCase = m_reservoirView->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCase = m_reservoirView->eclipseCase()->reservoirData();
RigMainGrid* grid = eclipseCase->mainGrid();
CVF_ASSERT(grid);
@ -649,7 +649,7 @@ QString RiuResultTextBuilder::cellResultText(RimEclipseCellColors* resultColors)
if (m_reservoirView->eclipseCase() && m_reservoirView->eclipseCase()->reservoirData())
{
RigCaseData* eclipseCaseData = m_reservoirView->eclipseCase()->reservoirData();
RigEclipseCaseData* eclipseCaseData = m_reservoirView->eclipseCase()->reservoirData();
RigGridBase* grid = eclipseCaseData->grid(m_gridIndex);
RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(resultColors->porosityModel());

4
ApplicationCode/UserInterface/RiuResultTextBuilder.h
View File

@ -27,7 +27,7 @@
class RimEclipseView;
class RimEclipseCellColors;
class QString;
class RigCaseData;
class RigEclipseCaseData;
namespace cvf {
class Part;
@ -65,7 +65,7 @@ private:
QString cellResultText(RimEclipseCellColors* resultColors);
void appendTextFromResultColors(RigCaseData* eclipseCase, size_t gridIndex, size_t cellIndex, size_t timeStepIndex, RimEclipseCellColors* resultColors, QString* resultInfoText);
void appendTextFromResultColors(RigEclipseCaseData* eclipseCase, size_t gridIndex, size_t cellIndex, size_t timeStepIndex, RimEclipseCellColors* resultColors, QString* resultInfoText);
private:
caf::PdmPointer<RimEclipseView> m_reservoirView;

2
ApplicationCode/UserInterface/RiuSelectionChangedHandler.cpp
View File

@ -22,7 +22,7 @@
#include "RiaApplication.h"
#include "RigCaseCellResultsData.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RiuFemTimeHistoryResultAccessor.h"
#include "RigGeoMechCaseData.h"
#include "RigTimeHistoryResultAccessor.h"

2
ApplicationCode/UserInterface/RiuViewerCommands.cpp
View File

@ -27,7 +27,7 @@
#include "RicRangeFilterNewExec.h"
#include "WellPathCommands/RicWellPathViewerEventHandler.h"
#include "RigCaseData.h"
#include "RigEclipseCaseData.h"
#include "RigFault.h"
#include "RigFemPartCollection.h"
#include "RigFemPartGrid.h"