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

Results Storage: A huge refactorisation to make way for storing generated properties to an internal file.

Browse Source 
This does not yet compile due to a unfortunate mix of perforce, cmake setup and unit_test project shortcomings.
Need to move RigStatistics into ProjectDataModel and rename it before this is running again.
p4#: 20945
This commit is contained in:
Jacob Støren
2013-03-18 14:34:29 +01:00
parent 62e4cac4b0
commit f7248f3999
27 changed files with 705 additions and 602 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
ApplicationCode/FileInterface/FileInterface_UnitTests/CMakeLists.txt
View File

@@ -18,6 +18,9 @@ include_directories(
${ResInsight_SOURCE_DIR}/cafProjectDataModel ${ResInsight_SOURCE_DIR}/cafProjectDataModel
${ResInsight_SOURCE_DIR}/CommonCode ${ResInsight_SOURCE_DIR}/CommonCode
#Remove when RigStatistics is out
${ResInsight_SOURCE_DIR}/ApplicationCode/ModelVisualization
) )

8
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@@ -377,9 +377,6 @@ bool RifReaderEclipseOutput::open(const QString& fileName, RigEclipseCase* eclip
m_eclipseCase = eclipseCase; m_eclipseCase = eclipseCase;
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(this);
eclipseCase->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(this);
// Build results meta data // Build results meta data
if (!buildMetaData()) return false; if (!buildMetaData()) return false;
progInfo.incrementProgress(); progInfo.incrementProgress();
@@ -397,7 +394,7 @@ bool RifReaderEclipseOutput::open(const QString& fileName, RigEclipseCase* eclip
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RifReaderEclipseOutput::openAndReadActiveCellData(const QString& fileName, RigEclipseCase* mainEclipseCase, RigEclipseCase* eclipseCase) bool RifReaderEclipseOutput::openAndReadActiveCellData(const QString& fileName, const std::vector<QDateTime>& mainCaseTimeSteps, RigEclipseCase* eclipseCase)
{ {
CVF_ASSERT(eclipseCase); CVF_ASSERT(eclipseCase);
@@ -417,8 +414,6 @@ bool RifReaderEclipseOutput::openAndReadActiveCellData(const QString& fileName,
m_fileSet = fileSet; m_fileSet = fileSet;
m_eclipseCase = eclipseCase; m_eclipseCase = eclipseCase;
eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(this);
eclipseCase->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(this);
if (!readActiveCellInfo()) if (!readActiveCellInfo())
{ {
@@ -432,7 +427,6 @@ bool RifReaderEclipseOutput::openAndReadActiveCellData(const QString& fileName,
m_dynamicResultsAccess = createDynamicResultsAccess(m_fileSet); m_dynamicResultsAccess = createDynamicResultsAccess(m_fileSet);
std::vector<QDateTime> mainCaseTimeSteps = mainEclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->readerInterface()->timeSteps();
m_dynamicResultsAccess->setTimeSteps(mainCaseTimeSteps); m_dynamicResultsAccess->setTimeSteps(mainCaseTimeSteps);
return true; return true;

2
ApplicationCode/FileInterface/RifReaderEclipseOutput.h
View File

@@ -44,7 +44,7 @@ public:
virtual ~RifReaderEclipseOutput(); virtual ~RifReaderEclipseOutput();
bool open(const QString& fileName, RigEclipseCase* eclipseCase); bool open(const QString& fileName, RigEclipseCase* eclipseCase);
virtual bool openAndReadActiveCellData(const QString& fileName, RigEclipseCase* mainEclipseCase, RigEclipseCase* eclipseCase); virtual bool openAndReadActiveCellData(const QString& fileName, const std::vector<QDateTime>& mainCaseTimeSteps, RigEclipseCase* eclipseCase);
void close(); void close();
bool staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values); bool staticResult(const QString& result, PorosityModelResultType matrixOrFracture, std::vector<double>* values);

16
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@@ -117,9 +117,9 @@ void Rim3dOverlayInfoConfig::update3DInfo()
double p10, p90; double p10, p90;
double mean; double mean;
size_t scalarIndex = m_reservoirView->cellResult()->gridScalarIndex(); size_t scalarIndex = m_reservoirView->cellResult()->gridScalarIndex();
m_reservoirView->currentGridCellResults()->minMaxCellScalarValues(scalarIndex, min, max); m_reservoirView->currentGridCellResults()->cellResults()->minMaxCellScalarValues(scalarIndex, min, max);
m_reservoirView->currentGridCellResults()->p10p90CellScalarValues(scalarIndex, p10, p90); m_reservoirView->currentGridCellResults()->cellResults()->p10p90CellScalarValues(scalarIndex, p10, p90);
m_reservoirView->currentGridCellResults()->meanCellScalarValues(scalarIndex, mean); m_reservoirView->currentGridCellResults()->cellResults()->meanCellScalarValues(scalarIndex, mean);
//infoText += QString("<blockquote><b>Min:</b> %1 <b>P10:</b> %2 <b>Mean:</b> %3 <b>P90:</b> %4 <b>Max:</b> %5 </blockquote>").arg(min).arg(p10).arg(mean).arg(p90).arg(max); //infoText += QString("<blockquote><b>Min:</b> %1 <b>P10:</b> %2 <b>Mean:</b> %3 <b>P90:</b> %4 <b>Max:</b> %5 </blockquote>").arg(min).arg(p10).arg(mean).arg(p90).arg(max);
//infoText += QString("<blockquote><pre>Min: %1 P10: %2 Mean: %3 \n P90: %4 Max: %5 </pre></blockquote>").arg(min).arg(p10).arg(mean).arg(p90).arg(max); //infoText += QString("<blockquote><pre>Min: %1 P10: %2 Mean: %3 \n P90: %4 Max: %5 </pre></blockquote>").arg(min).arg(p10).arg(mean).arg(p90).arg(max);
@@ -141,7 +141,7 @@ void Rim3dOverlayInfoConfig::update3DInfo()
|| m_reservoirView->wellCollection()->hasVisibleWellPipes()) || m_reservoirView->wellCollection()->hasVisibleWellPipes())
{ {
int currentTimeStep = m_reservoirView->currentTimeStep(); int currentTimeStep = m_reservoirView->currentTimeStep();
QDateTime date = m_reservoirView->currentGridCellResults()->timeStepDate(0, currentTimeStep); QDateTime date = m_reservoirView->currentGridCellResults()->cellResults()->timeStepDate(0, currentTimeStep);
infoText += QString("<b>Time Step:</b> %1 <b>Time:</b> %2").arg(currentTimeStep).arg(date.toString("dd.MMM yyyy")); infoText += QString("<b>Time Step:</b> %1 <b>Time:</b> %2").arg(currentTimeStep).arg(date.toString("dd.MMM yyyy"));
} }
@@ -157,12 +157,12 @@ void Rim3dOverlayInfoConfig::update3DInfo()
double mean; double mean;
size_t scalarIndex = m_reservoirView->cellResult()->gridScalarIndex(); size_t scalarIndex = m_reservoirView->cellResult()->gridScalarIndex();
m_reservoirView->currentGridCellResults()->minMaxCellScalarValues(scalarIndex, min, max); m_reservoirView->currentGridCellResults()->cellResults()->minMaxCellScalarValues(scalarIndex, min, max);
m_reservoirView->currentGridCellResults()->p10p90CellScalarValues(scalarIndex, p10, p90); m_reservoirView->currentGridCellResults()->cellResults()->p10p90CellScalarValues(scalarIndex, p10, p90);
m_reservoirView->currentGridCellResults()->meanCellScalarValues(scalarIndex, mean); m_reservoirView->currentGridCellResults()->cellResults()->meanCellScalarValues(scalarIndex, mean);
m_reservoirView->viewer()->showHistogram(true); m_reservoirView->viewer()->showHistogram(true);
m_reservoirView->viewer()->setHistogram(min, max, m_reservoirView->currentGridCellResults()->cellScalarValuesHistogram(scalarIndex)); m_reservoirView->viewer()->setHistogram(min, max, m_reservoirView->currentGridCellResults()->cellResults()->cellScalarValuesHistogram(scalarIndex));
m_reservoirView->viewer()->setHistogramPercentiles(p10, p90, mean); m_reservoirView->viewer()->setHistogramPercentiles(p10, p90, mean);
} }
} }

1
ApplicationCode/ProjectDataModel/RimCaseCollection.h
View File

@@ -26,7 +26,6 @@
#include "RimStatisticalCalculation.h" #include "RimStatisticalCalculation.h"
//================================================================================================== //==================================================================================================
// //
// //

6
ApplicationCode/ProjectDataModel/RimCellEdgeResultSlot.cpp
View File

@@ -133,7 +133,7 @@ QList<caf::PdmOptionItemInfo> RimCellEdgeResultSlot::calculateValueOptions(const
if (m_reservoirView && m_reservoirView->currentGridCellResults()) if (m_reservoirView && m_reservoirView->currentGridCellResults())
{ {
QStringList varList; QStringList varList;
varList = m_reservoirView->currentGridCellResults()->resultNames(RimDefines::STATIC_NATIVE); varList = m_reservoirView->currentGridCellResults()->cellResults()->resultNames(RimDefines::STATIC_NATIVE);
//TODO: Must also handle input properties //TODO: Must also handle input properties
//varList += m_reservoirView->gridCellResults()->resultNames(RimDefines::INPUT_PROPERTY); //varList += m_reservoirView->gridCellResults()->resultNames(RimDefines::INPUT_PROPERTY);
@@ -208,7 +208,7 @@ QStringList RimCellEdgeResultSlot::findResultVariableNames()
if (m_reservoirView && m_reservoirView->currentGridCellResults() && !resultVariable().isEmpty()) if (m_reservoirView && m_reservoirView->currentGridCellResults() && !resultVariable().isEmpty())
{ {
QStringList varList; QStringList varList;
varList = m_reservoirView->currentGridCellResults()->resultNames(RimDefines::STATIC_NATIVE); varList = m_reservoirView->currentGridCellResults()->cellResults()->resultNames(RimDefines::STATIC_NATIVE);
//TODO: Must handle Input properties //TODO: Must handle Input properties
int i; int i;
@@ -313,7 +313,7 @@ void RimCellEdgeResultSlot::minMaxCellEdgeValues(double& min, double& max)
{ {
double cMin, cMax; double cMin, cMax;
m_reservoirView->currentGridCellResults()->minMaxCellScalarValues(resultIndices[idx], cMin, cMax); m_reservoirView->currentGridCellResults()->cellResults()->minMaxCellScalarValues(resultIndices[idx], cMin, cMax);
globalMin = CVF_MIN(globalMin, cMin); globalMin = CVF_MIN(globalMin, cMin);
globalMax = CVF_MAX(globalMax, cMax); globalMax = CVF_MAX(globalMax, cMax);

4
ApplicationCode/ProjectDataModel/RimCellPropertyFilter.cpp
View File

@@ -143,10 +143,10 @@ void RimCellPropertyFilter::setDefaultValues()
size_t scalarIndex = resultDefinition->gridScalarIndex(); size_t scalarIndex = resultDefinition->gridScalarIndex();
if (scalarIndex != cvf::UNDEFINED_SIZE_T) if (scalarIndex != cvf::UNDEFINED_SIZE_T)
{ {
RigReservoirCellResults* results = m_parentContainer->reservoirView()->currentGridCellResults(); RimReservoirCellResultsCacher* results = m_parentContainer->reservoirView()->currentGridCellResults();
if (results) if (results)
{ {
results->minMaxCellScalarValues(scalarIndex, min, max); results->cellResults()->minMaxCellScalarValues(scalarIndex, min, max);
} }
} }

32
ApplicationCode/ProjectDataModel/RimInputReservoir.cpp
View File

@@ -72,18 +72,18 @@ void RimInputReservoir::openDataFileSet(const QStringList& filenames)
if (caseName().contains("Input Mock Debug Model")) if (caseName().contains("Input Mock Debug Model"))
{ {
cvf::ref<RifReaderInterface> readerInterface = this->createMockModel(this->caseName()); cvf::ref<RifReaderInterface> readerInterface = this->createMockModel(this->caseName());
m_rigEclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(readerInterface.p()); results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(readerInterface.p());
m_rigEclipseCase->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(readerInterface.p()); results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(readerInterface.p());
m_rigEclipseCase->activeCellInfo(RifReaderInterface::MATRIX_RESULTS)->computeDerivedData(); reservoirData()->activeCellInfo(RifReaderInterface::MATRIX_RESULTS)->computeDerivedData();
m_rigEclipseCase->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS)->computeDerivedData(); reservoirData()->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS)->computeDerivedData();
return; return;
} }
if (m_rigEclipseCase.isNull()) if (this->reservoirData() == NULL)
{ {
m_rigEclipseCase = new RigEclipseCase; this->setReservoirData(new RigEclipseCase);
} }
// First find and read the grid data // First find and read the grid data
@@ -157,7 +157,7 @@ void RimInputReservoir::openDataFileSet(const QStringList& filenames)
bool RimInputReservoir::openEclipseGridFile() bool RimInputReservoir::openEclipseGridFile()
{ {
// Early exit if reservoir data is created // Early exit if reservoir data is created
if (m_rigEclipseCase.isNull()) if (this->reservoirData() == NULL)
{ {
cvf::ref<RifReaderInterface> readerInterface; cvf::ref<RifReaderInterface> readerInterface;
@@ -174,14 +174,14 @@ bool RimInputReservoir::openEclipseGridFile()
return false; return false;
} }
m_rigEclipseCase = eclipseCase; this->setReservoirData( eclipseCase.p() );
} }
CVF_ASSERT(m_rigEclipseCase.notNull()); CVF_ASSERT(this->reservoirData());
CVF_ASSERT(readerInterface.notNull()); CVF_ASSERT(readerInterface.notNull());
m_rigEclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(readerInterface.p()); results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(readerInterface.p());
m_rigEclipseCase->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(readerInterface.p()); results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(readerInterface.p());
computeCachedData(); computeCachedData();
loadAndSyncronizeInputProperties(); loadAndSyncronizeInputProperties();
@@ -191,8 +191,8 @@ bool RimInputReservoir::openEclipseGridFile()
RIApplication* app = RIApplication::instance(); RIApplication* app = RIApplication::instance();
if (app->preferences()->autocomputeDepthRelatedProperties) if (app->preferences()->autocomputeDepthRelatedProperties)
{ {
RigReservoirCellResults* matrixResults = m_rigEclipseCase->results(RifReaderInterface::MATRIX_RESULTS); RimReservoirCellResultsCacher* matrixResults = results(RifReaderInterface::MATRIX_RESULTS);
RigReservoirCellResults* fractureResults = m_rigEclipseCase->results(RifReaderInterface::FRACTURE_RESULTS); RimReservoirCellResultsCacher* fractureResults = results(RifReaderInterface::FRACTURE_RESULTS);
matrixResults->computeDepthRelatedResults(); matrixResults->computeDepthRelatedResults();
fractureResults->computeDepthRelatedResults(); fractureResults->computeDepthRelatedResults();
@@ -210,7 +210,7 @@ void RimInputReservoir::loadAndSyncronizeInputProperties()
{ {
// Make sure we actually have reservoir data // Make sure we actually have reservoir data
CVF_ASSERT(m_rigEclipseCase.notNull()); CVF_ASSERT(this->reservoirData());
CVF_ASSERT(this->reservoirData()->mainGrid()->gridPointDimensions() != cvf::Vec3st(0,0,0)); CVF_ASSERT(this->reservoirData()->mainGrid()->gridPointDimensions() != cvf::Vec3st(0,0,0));
// Then read the properties from all the files referenced by the InputReservoir // Then read the properties from all the files referenced by the InputReservoir
@@ -359,7 +359,7 @@ void RimInputReservoir::removeProperty(RimInputProperty* inputProperty)
} }
// Remove the results pointed to by this input property // Remove the results pointed to by this input property
RigReservoirCellResults* results = m_rigEclipseCase->results(RifReaderInterface::MATRIX_RESULTS); RigReservoirCellResults* results = reservoirData()->results(RifReaderInterface::MATRIX_RESULTS);
results->removeResult(inputProperty->resultName); results->removeResult(inputProperty->resultName);
this->removeResult(inputProperty->resultName); this->removeResult(inputProperty->resultName);
@@ -404,7 +404,7 @@ cvf::ref<RifReaderInterface> RimInputReservoir::createMockModel(QString modelNam
m_inputPropertyCollection->inputProperties.push_back(inputProperty); m_inputPropertyCollection->inputProperties.push_back(inputProperty);
} }
m_rigEclipseCase = reservoir; this->setReservoirData( reservoir.p() );
return mockFileInterface.p(); return mockFileInterface.p();
} }

94
ApplicationCode/ProjectDataModel/RimReservoir.cpp
View File

@@ -34,6 +34,7 @@
#include <QString> #include <QString>
#include "RimProject.h" #include "RimProject.h"
#include "RimReservoirCellResultsCacher.h"
CAF_PDM_SOURCE_INIT(RimReservoir, "RimReservoir"); CAF_PDM_SOURCE_INIT(RimReservoir, "RimReservoir");
@@ -42,15 +43,33 @@ CAF_PDM_SOURCE_INIT(RimReservoir, "RimReservoir");
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimReservoir::RimReservoir() RimReservoir::RimReservoir()
{ {
m_rigEclipseCase = NULL;
CAF_PDM_InitField(&caseName, "CaseName", QString(), "Case name", "", "" ,""); CAF_PDM_InitField(&caseName, "CaseName", QString(), "Case name", "", "" ,"");
// CAF_PDM_InitField(&releaseResultMemory, "ReleaseResultMemory", true, "Release result memory", "", "" ,"");
// releaseResultMemory.setIOReadable(false);
// releaseResultMemory.setIOWritable(false);
// releaseResultMemory.setUiEditorTypeName(caf::PdmUiPushButtonEditor::uiEditorTypeName());
CAF_PDM_InitFieldNoDefault(&reservoirViews, "ReservoirViews", "", "", "", ""); CAF_PDM_InitFieldNoDefault(&reservoirViews, "ReservoirViews", "", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_matrixModelResults, "MatrixModelResults", "", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_fractureModelResults, "FractureModelResults", "", "", "", "");
m_matrixModelResults = new RimReservoirCellResultsCacher;
m_fractureModelResults = new RimReservoirCellResultsCacher;
this->setReservoirData( NULL );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimReservoir::~RimReservoir()
{
reservoirViews.deleteAllChildObjects();
delete m_matrixModelResults();
delete m_fractureModelResults();
if (this->reservoirData())
{
// At this point, we assume that memory should be released
CVF_ASSERT(this->reservoirData()->refCount() == 1);
}
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -84,20 +103,6 @@ void RimReservoir::initAfterRead()
} }
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimReservoir::~RimReservoir()
{
reservoirViews.deleteAllChildObjects();
if (m_rigEclipseCase.notNull())
{
// At this point, we assume that memory should be released
CVF_ASSERT(m_rigEclipseCase->refCount() == 1);
}
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -106,12 +111,12 @@ RimReservoirView* RimReservoir::createAndAddReservoirView()
// If parent is collection, and number of views is zero, make sure rig is set to NULL to initiate normal case loading // If parent is collection, and number of views is zero, make sure rig is set to NULL to initiate normal case loading
if (parentCaseCollection() != NULL && reservoirViews().size() == 0) if (parentCaseCollection() != NULL && reservoirViews().size() == 0)
{ {
if (m_rigEclipseCase.notNull()) if (this->reservoirData())
{ {
CVF_ASSERT(m_rigEclipseCase->refCount() == 1); CVF_ASSERT(this->reservoirData()->refCount() == 1);
} }
m_rigEclipseCase = NULL; this->setReservoirData( NULL );
} }
RimReservoirView* riv = new RimReservoirView(); RimReservoirView* riv = new RimReservoirView();
@@ -207,7 +212,7 @@ void RimReservoir::fieldChangedByUi(const caf::PdmFieldHandle* changedField, con
{ {
if (changedField == &releaseResultMemory) if (changedField == &releaseResultMemory)
{ {
if (m_rigEclipseCase.notNull()) if (this->reservoirData())
{ {
for (size_t i = 0; i < reservoirViews().size(); i++) for (size_t i = 0; i < reservoirViews().size(); i++)
{ {
@@ -229,13 +234,13 @@ void RimReservoir::fieldChangedByUi(const caf::PdmFieldHandle* changedField, con
reservoirView->createDisplayModelAndRedraw(); reservoirView->createDisplayModelAndRedraw();
} }
RigReservoirCellResults* matrixModelResults = m_rigEclipseCase->results(RifReaderInterface::MATRIX_RESULTS); RigReservoirCellResults* matrixModelResults = reservoirData()->results(RifReaderInterface::MATRIX_RESULTS);
if (matrixModelResults) if (matrixModelResults)
{ {
matrixModelResults->clearAllResults(); matrixModelResults->clearAllResults();
} }
RigReservoirCellResults* fractureModelResults = m_rigEclipseCase->results(RifReaderInterface::FRACTURE_RESULTS); RigReservoirCellResults* fractureModelResults = reservoirData()->results(RifReaderInterface::FRACTURE_RESULTS);
if (fractureModelResults) if (fractureModelResults)
{ {
fractureModelResults->clearAllResults(); fractureModelResults->clearAllResults();
@@ -286,3 +291,38 @@ RimCaseCollection* RimReservoir::parentCaseCollection()
return NULL; return NULL;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoir::setReservoirData(RigEclipseCase* eclipseCase)
{
m_rigEclipseCase = eclipseCase;
if (this->reservoirData())
{
m_fractureModelResults()->setCellResults(reservoirData()->results(RifReaderInterface::FRACTURE_RESULTS));
m_matrixModelResults()->setCellResults(reservoirData()->results(RifReaderInterface::MATRIX_RESULTS));
m_fractureModelResults()->setMainGrid(this->reservoirData()->mainGrid());
m_matrixModelResults()->setMainGrid(this->reservoirData()->mainGrid());
}
else
{
m_fractureModelResults()->setCellResults(NULL);
m_matrixModelResults()->setCellResults(NULL);
m_fractureModelResults()->setMainGrid(NULL);
m_matrixModelResults()->setMainGrid(NULL);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimReservoirCellResultsCacher* RimReservoir::results(RifReaderInterface::PorosityModelResultType porosityModel)
{
if (porosityModel == RifReaderInterface::MATRIX_RESULTS)
{
return m_matrixModelResults();
}
return m_fractureModelResults();
}

35
ApplicationCode/ProjectDataModel/RimReservoir.h
View File

@@ -22,7 +22,8 @@
#include "cvfObject.h" #include "cvfObject.h"
#include "cafPdmField.h" #include "cafPdmField.h"
#include "cafPdmObject.h" #include "cafPdmObject.h"
#include "RimReservoirCellResultsCacher.h"
#include "RifReaderInterface.h"
class QString; class QString;
@@ -30,12 +31,11 @@ class RigEclipseCase;
class RigGridBase; class RigGridBase;
class RimReservoirView; class RimReservoirView;
class RimCaseCollection; class RimCaseCollection;
//class RimReservoirCellResultsCacher;
//================================================================================================== //==================================================================================================
// //
// Interface for reservoirs. // Interface for reservoirs.
// As this is a pure virtual class, the factory macros are not relevant (nor possible) to use
// CAF_PDM_HEADER_INIT and CAF_PDM_SOURCE_INIT
// //
//================================================================================================== //==================================================================================================
class RimReservoir : public caf::PdmObject class RimReservoir : public caf::PdmObject
@@ -45,38 +45,45 @@ public:
RimReservoir(); RimReservoir();
virtual ~RimReservoir(); virtual ~RimReservoir();
// Fields:
caf::PdmField<QString> caseName;
caf::PdmField<bool> releaseResultMemory;
caf::PdmPointersField<RimReservoirView*> reservoirViews;
virtual bool openEclipseGridFile() { return false;}; // Should be pure virtual but PDM does not allow that. virtual bool openEclipseGridFile() { return false;}; // Should be pure virtual but PDM does not allow that.
RigEclipseCase* reservoirData(); RigEclipseCase* reservoirData();
const RigEclipseCase* reservoirData() const; const RigEclipseCase* reservoirData() const;
RimReservoirCellResultsCacher* results(RifReaderInterface::PorosityModelResultType porosityModel);
RimReservoirView* createAndAddReservoirView(); RimReservoirView* createAndAddReservoirView();
void removeReservoirView(RimReservoirView* reservoirView); void removeReservoirView(RimReservoirView* reservoirView);
void removeResult(const QString& resultName); void removeResult(const QString& resultName);
// Fields:
caf::PdmField<QString> caseName;
caf::PdmField<bool> releaseResultMemory;
caf::PdmPointersField<RimReservoirView*> reservoirViews;
virtual caf::PdmFieldHandle* userDescriptionField() { return &caseName; }
virtual QString locationOnDisc() const { return QString(); } virtual QString locationOnDisc() const { return QString(); }
// Overridden methods from PdmObject
public:
virtual caf::PdmFieldHandle* userDescriptionField() { return &caseName; }
protected: protected:
// Overridden methods
virtual void initAfterRead(); virtual void initAfterRead();
virtual void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ); virtual void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue );
// Internal methods
protected:
void computeCachedData(); void computeCachedData();
void setReservoirData(RigEclipseCase* eclipseCase);
private: private:
RimCaseCollection* parentCaseCollection(); RimCaseCollection* parentCaseCollection();
protected: private:
cvf::ref<RigEclipseCase> m_rigEclipseCase; cvf::ref<RigEclipseCase> m_rigEclipseCase;
private:
caf::PdmField<RimReservoirCellResultsCacher*> m_matrixModelResults;
caf::PdmField<RimReservoirCellResultsCacher*> m_fractureModelResults;
}; };

406
ApplicationCode/ProjectDataModel/RimReservoirCellResultsCacher.cpp
View File

@@ -20,6 +20,8 @@
#include "RimReservoirCellResultsCacher.h" #include "RimReservoirCellResultsCacher.h"
#include "RigReservoirCellResults.h" #include "RigReservoirCellResults.h"
#include "RIApplication.h" #include "RIApplication.h"
#include "RigMainGrid.h"
#include "RigCell.h"
CAF_PDM_SOURCE_INIT(RimReservoirCellResultsCacher, "ReservoirCellResultCacher"); CAF_PDM_SOURCE_INIT(RimReservoirCellResultsCacher, "ReservoirCellResultCacher");
@@ -27,7 +29,8 @@ CAF_PDM_SOURCE_INIT(RimReservoirCellResultsCacher, "ReservoirCellResultCacher");
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimReservoirCellResultsCacher::RimReservoirCellResultsCacher() RimReservoirCellResultsCacher::RimReservoirCellResultsCacher()
: m_cellResults(NULL) : m_cellResults(NULL),
m_ownerMainGrid(NULL)
{ {
CAF_PDM_InitObject("Cacher", "", "", ""); CAF_PDM_InitObject("Cacher", "", "", "");
@@ -71,6 +74,9 @@ void RimReservoirCellResultsCacher::setupBeforeSave()
stream << (qint32)1; // Version stream << (qint32)1; // Version
for (int rIdx = 0; rIdx < resInfo.size(); ++rIdx) for (int rIdx = 0; rIdx < resInfo.size(); ++rIdx)
{
size_t timestepCount = m_cellResults->cellScalarResults(resInfo[rIdx].m_gridScalarResultIndex).size();
if (timestepCount)
{ {
RimReservoirCellResultsCacheEntryInfo* cacheEntry = new RimReservoirCellResultsCacheEntryInfo; RimReservoirCellResultsCacheEntryInfo* cacheEntry = new RimReservoirCellResultsCacheEntryInfo;
m_resultCacheMetaData.push_back(cacheEntry); m_resultCacheMetaData.push_back(cacheEntry);
@@ -83,14 +89,19 @@ void RimReservoirCellResultsCacher::setupBeforeSave()
for (int tsIdx = 0; tsIdx < resInfo[rIdx].m_timeStepDates.size() ; ++tsIdx) for (int tsIdx = 0; tsIdx < resInfo[rIdx].m_timeStepDates.size() ; ++tsIdx)
{ {
std::vector<double>& data = m_cellResults->cellScalarResults(resInfo[rIdx].m_gridScalarResultIndex, tsIdx); const std::vector<double>* data = NULL;
if (data.size()) if (tsIdx < timestepCount)
{
data = &(m_cellResults->cellScalarResults(resInfo[rIdx].m_gridScalarResultIndex, tsIdx));
}
if (data && data->size())
{ {
cacheEntry->m_timeStepHasData.v().push_back(1); cacheEntry->m_timeStepHasData.v().push_back(1);
for (size_t cIdx = 0; cIdx < data.size(); ++cIdx) for (size_t cIdx = 0; cIdx < data->size(); ++cIdx)
{ {
stream << data[cIdx]; stream << (*data)[cIdx];
} }
} }
else else
@@ -101,6 +112,7 @@ void RimReservoirCellResultsCacher::setupBeforeSave()
} }
} }
} }
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
@@ -138,6 +150,390 @@ QString RimReservoirCellResultsCacher::getCacheDirectoryPath()
return cacheDirPath; return cacheDirPath;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirCellResultsCacher::setReaderInterface(RifReaderInterface* readerInterface)
{
m_readerInterface = readerInterface;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifReaderInterface* RimReservoirCellResultsCacher::readerInterface()
{
return m_readerInterface.p();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RimReservoirCellResultsCacher::findOrLoadScalarResultForTimeStep(RimDefines::ResultCatType type, const QString& resultName, size_t timeStepIndex)
{
// Special handling for SOIL
if (type == RimDefines::DYNAMIC_NATIVE && resultName.toUpper() == "SOIL")
{
loadOrComputeSOILForTimeStep(timeStepIndex);
}
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T;
scalarResultIndex = m_cellResults->findScalarResultIndex(type, resultName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T) return cvf::UNDEFINED_SIZE_T;
if (type == RimDefines::GENERATED)
{
return cvf::UNDEFINED_SIZE_T;
}
if (m_readerInterface.notNull())
{
size_t timeStepCount = m_cellResults->infoForEachResultIndex()[scalarResultIndex].m_timeStepDates.size();
bool resultLoadingSucess = true;
if (type == RimDefines::DYNAMIC_NATIVE && timeStepCount > 0)
{
m_cellResults->cellScalarResults(scalarResultIndex).resize(timeStepCount);
std::vector<double>& values = m_cellResults->cellScalarResults(scalarResultIndex)[timeStepIndex];
if (values.size() == 0)
{
if (!m_readerInterface->dynamicResult(resultName, RifReaderInterface::MATRIX_RESULTS, timeStepIndex, &values))
{
resultLoadingSucess = false;
}
}
}
else if (type == RimDefines::STATIC_NATIVE)
{
m_cellResults->cellScalarResults(scalarResultIndex).resize(1);
std::vector<double>& values = m_cellResults->cellScalarResults(scalarResultIndex)[0];
if (!m_readerInterface->staticResult(resultName, RifReaderInterface::MATRIX_RESULTS, &values))
{
resultLoadingSucess = false;
}
}
if (!resultLoadingSucess)
{
// Error logging
CVF_ASSERT(false);
}
}
return scalarResultIndex;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RimReservoirCellResultsCacher::findOrLoadScalarResult(RimDefines::ResultCatType type, const QString& resultName)
{
size_t resultGridIndex = cvf::UNDEFINED_SIZE_T;
resultGridIndex = m_cellResults->findScalarResultIndex(type, resultName);
if (resultGridIndex == cvf::UNDEFINED_SIZE_T) return cvf::UNDEFINED_SIZE_T;
if (m_cellResults->cellScalarResults(resultGridIndex).size()) return resultGridIndex;
if (type == RimDefines::GENERATED)
{
return cvf::UNDEFINED_SIZE_T;
}
if (m_readerInterface.notNull())
{
// Add one more result to result container
size_t timeStepCount = m_cellResults->infoForEachResultIndex()[resultGridIndex].m_timeStepDates.size();
bool resultLoadingSucess = true;
if (type == RimDefines::DYNAMIC_NATIVE && timeStepCount > 0)
{
m_cellResults->cellScalarResults(resultGridIndex).resize(timeStepCount);
size_t i;
for (i = 0; i < timeStepCount; i++)
{
std::vector<double>& values = m_cellResults->cellScalarResults(resultGridIndex)[i];
if (!m_readerInterface->dynamicResult(resultName, RifReaderInterface::MATRIX_RESULTS, i, &values))
{
resultLoadingSucess = false;
}
}
}
else if (type == RimDefines::STATIC_NATIVE)
{
m_cellResults->cellScalarResults(resultGridIndex).resize(1);
std::vector<double>& values = m_cellResults->cellScalarResults(resultGridIndex)[0];
if (!m_readerInterface->staticResult(resultName, RifReaderInterface::MATRIX_RESULTS, &values))
{
resultLoadingSucess = false;
}
}
if (!resultLoadingSucess)
{
// Remove last scalar result because loading of result failed
m_cellResults->cellScalarResults(resultGridIndex).clear();
}
}
return resultGridIndex;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirCellResultsCacher::loadOrComputeSOIL()
{
for (size_t timeStepIdx = 0; timeStepIdx < m_cellResults->maxTimeStepCount(); timeStepIdx++)
{
loadOrComputeSOILForTimeStep(timeStepIdx);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirCellResultsCacher::loadOrComputeSOILForTimeStep(size_t timeStepIndex)
{
size_t scalarIndexSWAT = findOrLoadScalarResultForTimeStep(RimDefines::DYNAMIC_NATIVE, "SWAT", timeStepIndex);
size_t scalarIndexSGAS = findOrLoadScalarResultForTimeStep(RimDefines::DYNAMIC_NATIVE, "SGAS", timeStepIndex);
// Early exit if none of SWAT or SGAS is present
if (scalarIndexSWAT == cvf::UNDEFINED_SIZE_T && scalarIndexSGAS == cvf::UNDEFINED_SIZE_T)
{
return;
}
size_t soilResultValueCount = 0;
size_t soilTimeStepCount = 0;
std::vector<double>* swatForTimeStep = NULL;
std::vector<double>* sgasForTimeStep = NULL;
if (scalarIndexSWAT != cvf::UNDEFINED_SIZE_T)
{
swatForTimeStep = &(m_cellResults->cellScalarResults(scalarIndexSWAT, timeStepIndex));
if (swatForTimeStep->size() == 0)
{
swatForTimeStep = NULL;
}
else
{
soilResultValueCount = swatForTimeStep->size();
soilTimeStepCount = m_cellResults->infoForEachResultIndex()[scalarIndexSWAT].m_timeStepDates.size();
}
}
if (scalarIndexSGAS != cvf::UNDEFINED_SIZE_T)
{
sgasForTimeStep = &(m_cellResults->cellScalarResults(scalarIndexSGAS, timeStepIndex));
if (sgasForTimeStep->size() == 0)
{
sgasForTimeStep = NULL;
}
else
{
soilResultValueCount = qMax(soilResultValueCount, sgasForTimeStep->size());
size_t sgasTimeStepCount = m_cellResults->infoForEachResultIndex()[scalarIndexSGAS].m_timeStepDates.size();
soilTimeStepCount = qMax(soilTimeStepCount, sgasTimeStepCount);
}
}
size_t soilResultGridIndex = findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SOIL");
if (soilResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
soilResultGridIndex = m_cellResults->addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, "SOIL");
CVF_ASSERT(soilResultGridIndex != cvf::UNDEFINED_SIZE_T);
m_cellResults->cellScalarResults(soilResultGridIndex).resize(soilTimeStepCount);
for (size_t timeStepIdx = 0; timeStepIdx < soilTimeStepCount; timeStepIdx++)
{
m_cellResults->cellScalarResults(soilResultGridIndex, timeStepIdx).resize(soilResultValueCount);
}
}
std::vector<double>& soilForTimeStep = m_cellResults->cellScalarResults(soilResultGridIndex, timeStepIndex);
#pragma omp parallel for
for (int idx = 0; idx < static_cast<int>(soilResultValueCount); idx++)
{
double soilValue = 1.0;
if (sgasForTimeStep)
{
soilValue -= sgasForTimeStep->at(idx);
}
if (swatForTimeStep)
{
soilValue -= swatForTimeStep->at(idx);
}
soilForTimeStep[idx] = soilValue;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirCellResultsCacher::computeDepthRelatedResults()
{
size_t depthResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DEPTH");
size_t dxResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DX");
size_t dyResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DY");
size_t dzResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DZ");
size_t topsResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "TOPS");
size_t bottomResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "BOTTOM");
bool computeDepth = false;
bool computeDx = false;
bool computeDy = false;
bool computeDz = false;
bool computeTops = false;
bool computeBottom = false;
size_t resultValueCount = m_ownerMainGrid->cells().size();
if (depthResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
depthResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "DEPTH", resultValueCount);
computeDepth = true;
}
if (dxResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
dxResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "DX", resultValueCount);
computeDx = true;
}
if (dyResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
dyResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "DY", resultValueCount);
computeDy = true;
}
if (dzResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
dzResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "DZ", resultValueCount);
computeDz = true;
}
if (topsResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
topsResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "TOPS", resultValueCount);
computeTops = true;
}
if (bottomResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
bottomResultGridIndex = m_cellResults->addStaticScalarResult(RimDefines::STATIC_NATIVE, "BOTTOM", resultValueCount);
computeBottom = true;
}
std::vector< std::vector<double> >& depth = m_cellResults->cellScalarResults(depthResultGridIndex);
std::vector< std::vector<double> >& dx = m_cellResults->cellScalarResults(dxResultGridIndex);
std::vector< std::vector<double> >& dy = m_cellResults->cellScalarResults(dyResultGridIndex);
std::vector< std::vector<double> >& dz = m_cellResults->cellScalarResults(dzResultGridIndex);
std::vector< std::vector<double> >& tops = m_cellResults->cellScalarResults(topsResultGridIndex);
std::vector< std::vector<double> >& bottom = m_cellResults->cellScalarResults(bottomResultGridIndex);
size_t cellIdx = 0;
for (cellIdx = 0; cellIdx < m_ownerMainGrid->cells().size(); cellIdx++)
{
const RigCell& cell = m_ownerMainGrid->cells()[cellIdx];
if (computeDepth)
{
depth[0][cellIdx] = cvf::Math::abs(cell.center().z());
}
if (computeDx)
{
cvf::Vec3d cellWidth = cell.faceCenter(cvf::StructGridInterface::NEG_I) - cell.faceCenter(cvf::StructGridInterface::POS_I);
dx[0][cellIdx] = cvf::Math::abs(cellWidth.x());
}
if (computeDy)
{
cvf::Vec3d cellWidth = cell.faceCenter(cvf::StructGridInterface::NEG_J) - cell.faceCenter(cvf::StructGridInterface::POS_J);
dy[0][cellIdx] = cvf::Math::abs(cellWidth.y());
}
if (computeDz)
{
cvf::Vec3d cellWidth = cell.faceCenter(cvf::StructGridInterface::NEG_K) - cell.faceCenter(cvf::StructGridInterface::POS_K);
dz[0][cellIdx] = cvf::Math::abs(cellWidth.z());
}
if (computeTops)
{
tops[0][cellIdx] = cvf::Math::abs(cell.faceCenter(cvf::StructGridInterface::NEG_K).z());
}
if (computeBottom)
{
bottom[0][cellIdx] = cvf::Math::abs(cell.faceCenter(cvf::StructGridInterface::POS_K).z());
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RimReservoirCellResultsCacher::findOrLoadScalarResult(const QString& resultName)
{
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T;
scalarResultIndex = this->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, resultName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = this->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, resultName);
}
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::GENERATED, resultName);
}
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::INPUT_PROPERTY, resultName);
}
return scalarResultIndex;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirCellResultsCacher::setCellResults(RigReservoirCellResults* cellResults)
{
m_cellResults = cellResults;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirCellResultsCacher::setMainGrid(RigMainGrid* mainGrid)
{
m_ownerMainGrid = mainGrid;
}
CAF_PDM_SOURCE_INIT(RimReservoirCellResultsCacheEntryInfo, "ResultCacheEntryInfo"); CAF_PDM_SOURCE_INIT(RimReservoirCellResultsCacheEntryInfo, "ResultCacheEntryInfo");

34
ApplicationCode/ProjectDataModel/RimReservoirCellResultsCacher.h
View File

@@ -26,6 +26,8 @@
class RimReservoirCellResultsCacheEntryInfo; class RimReservoirCellResultsCacheEntryInfo;
class RigReservoirCellResults; class RigReservoirCellResults;
class RifReaderInterface;
class RigMainGrid;
class RimReservoirCellResultsCacher : public caf::PdmObject class RimReservoirCellResultsCacher : public caf::PdmObject
{ {
@@ -34,23 +36,37 @@ public:
RimReservoirCellResultsCacher(); RimReservoirCellResultsCacher();
virtual ~RimReservoirCellResultsCacher(); virtual ~RimReservoirCellResultsCacher();
//RigReservoirCellResults* cellResults() const { return m_cellResults; } // Fields
void setCellResults(RigReservoirCellResults* cellResults) { m_cellResults = cellResults; }
virtual void setupBeforeSave();
caf::PdmField<QString> m_resultCacheFileName; caf::PdmField<QString> m_resultCacheFileName;
caf::PdmPointersField<RimReservoirCellResultsCacheEntryInfo*> m_resultCacheMetaData; caf::PdmPointersField<RimReservoirCellResultsCacheEntryInfo*>
m_resultCacheMetaData;
RigReservoirCellResults* cellResults() { return m_cellResults; }
const RigReservoirCellResults* cellResults() const { return m_cellResults; }
void setCellResults(RigReservoirCellResults* cellResults);
void setMainGrid(RigMainGrid* mainGrid);
void setReaderInterface(RifReaderInterface* readerInterface);
RifReaderInterface* readerInterface();
void loadOrComputeSOIL();
void loadOrComputeSOILForTimeStep(size_t timeStepIndex);
void computeDepthRelatedResults();
size_t findOrLoadScalarResultForTimeStep(RimDefines::ResultCatType type, const QString& resultName, size_t timeStepIndex);
size_t findOrLoadScalarResult(RimDefines::ResultCatType type, const QString& resultName);
size_t findOrLoadScalarResult(const QString& resultName); ///< Simplified search. Assumes unique names across types.
// Overridden methods from PdmObject
virtual void setupBeforeSave();
private: private:
QString getValidCacheFileName(); QString getValidCacheFileName();
QString getCacheDirectoryPath(); QString getCacheDirectoryPath();
cvf::ref<RifReaderInterface> m_readerInterface;
RigReservoirCellResults* m_cellResults; RigReservoirCellResults* m_cellResults;
RigMainGrid* m_ownerMainGrid;
}; };
class RimReservoirCellResultsCacheEntryInfo : public caf::PdmObject class RimReservoirCellResultsCacheEntryInfo : public caf::PdmObject

19
ApplicationCode/ProjectDataModel/RimReservoirView.cpp
View File

@@ -272,11 +272,11 @@ void RimReservoirView::updateViewerWidgetWindowTitle()
void RimReservoirView::clampCurrentTimestep() void RimReservoirView::clampCurrentTimestep()
{ {
// Clamp the current timestep to actual possibilities // Clamp the current timestep to actual possibilities
if (this->currentGridCellResults()) if (this->currentGridCellResults()->cellResults())
{ {
if (m_currentTimeStep() >= static_cast<int>(this->currentGridCellResults()->maxTimeStepCount())) if (m_currentTimeStep() >= static_cast<int>(this->currentGridCellResults()->cellResults()->maxTimeStepCount()))
{ {
m_currentTimeStep = static_cast<int>(this->currentGridCellResults()->maxTimeStepCount()) -1; m_currentTimeStep = static_cast<int>(this->currentGridCellResults()->cellResults()->maxTimeStepCount()) -1;
} }
} }
@@ -463,7 +463,7 @@ void RimReservoirView::createDisplayModel()
CVF_ASSERT(currentGridCellResults()); CVF_ASSERT(currentGridCellResults());
size_t i; size_t i;
for (i = 0; i < currentGridCellResults()->maxTimeStepCount(); i++) for (i = 0; i < currentGridCellResults()->cellResults()->maxTimeStepCount(); i++)
{ {
timeStepIndices.push_back(i); timeStepIndices.push_back(i);
} }
@@ -711,7 +711,7 @@ void RimReservoirView::loadDataAndUpdate()
RIApplication* app = RIApplication::instance(); RIApplication* app = RIApplication::instance();
if (app->preferences()->autocomputeSOIL) if (app->preferences()->autocomputeSOIL)
{ {
RigReservoirCellResults* results = currentGridCellResults(); RimReservoirCellResultsCacher* results = currentGridCellResults();
CVF_ASSERT(results); CVF_ASSERT(results);
results->loadOrComputeSOIL(); results->loadOrComputeSOIL();
} }
@@ -970,16 +970,13 @@ void RimReservoirView::setupBeforeSave()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Convenience for quick access to results /// Convenience for quick access to results
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigReservoirCellResults* RimReservoirView::currentGridCellResults() RimReservoirCellResultsCacher* RimReservoirView::currentGridCellResults()
{ {
if (m_reservoir && if (m_reservoir)
m_reservoir->reservoirData() &&
m_reservoir->reservoirData()->mainGrid()
)
{ {
RifReaderInterface::PorosityModelResultType porosityModel = RigReservoirCellResults::convertFromProjectModelPorosityModel(cellResult->porosityModel()); RifReaderInterface::PorosityModelResultType porosityModel = RigReservoirCellResults::convertFromProjectModelPorosityModel(cellResult->porosityModel());
return m_reservoir->reservoirData()->results(porosityModel); return m_reservoir->results(porosityModel);
} }
return NULL; return NULL;

2
ApplicationCode/ProjectDataModel/RimReservoirView.h
View File

@@ -118,7 +118,7 @@ public:
caf::PdmField<bool> animationMode; caf::PdmField<bool> animationMode;
// Access internal objects // Access internal objects
RigReservoirCellResults* currentGridCellResults(); RimReservoirCellResultsCacher* currentGridCellResults();
RigActiveCellInfo* currentActiveCellInfo(); RigActiveCellInfo* currentActiveCellInfo();
void setEclipseCase(RimReservoir* reservoir); void setEclipseCase(RimReservoir* reservoir);

16
ApplicationCode/ProjectDataModel/RimResultDefinition.cpp
View File

@@ -94,7 +94,7 @@ QList<caf::PdmOptionItemInfo> RimResultDefinition::calculateValueOptions(const c
{ {
if (m_reservoirView && m_reservoirView->currentGridCellResults()) if (m_reservoirView && m_reservoirView->currentGridCellResults())
{ {
QStringList varList = m_reservoirView->currentGridCellResults()->resultNames(resultType()); QStringList varList = m_reservoirView->currentGridCellResults()->cellResults()->resultNames(resultType());
QList<caf::PdmOptionItemInfo> optionList; QList<caf::PdmOptionItemInfo> optionList;
int i; int i;
for (i = 0; i < varList.size(); ++i) for (i = 0; i < varList.size(); ++i)
@@ -119,8 +119,8 @@ size_t RimResultDefinition::gridScalarIndex() const
{ {
if (m_gridScalarResultIndex == cvf::UNDEFINED_SIZE_T) if (m_gridScalarResultIndex == cvf::UNDEFINED_SIZE_T)
{ {
const RigReservoirCellResults* gridCellResults = m_reservoirView->currentGridCellResults(); const RimReservoirCellResultsCacher* gridCellResults = m_reservoirView->currentGridCellResults();
if (gridCellResults) m_gridScalarResultIndex = gridCellResults->findScalarResultIndex(resultType(), resultVariable()); if (gridCellResults) m_gridScalarResultIndex = gridCellResults->cellResults()->findScalarResultIndex(resultType(), resultVariable());
} }
return m_gridScalarResultIndex; return m_gridScalarResultIndex;
} }
@@ -130,7 +130,7 @@ size_t RimResultDefinition::gridScalarIndex() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimResultDefinition::loadResult() void RimResultDefinition::loadResult()
{ {
RigReservoirCellResults* gridCellResults = m_reservoirView->currentGridCellResults(); RimReservoirCellResultsCacher* gridCellResults = m_reservoirView->currentGridCellResults();
if (gridCellResults) if (gridCellResults)
{ {
m_gridScalarResultIndex = gridCellResults->findOrLoadScalarResult(resultType(), resultVariable); m_gridScalarResultIndex = gridCellResults->findOrLoadScalarResult(resultType(), resultVariable);
@@ -148,8 +148,8 @@ void RimResultDefinition::loadResult()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimResultDefinition::hasStaticResult() const bool RimResultDefinition::hasStaticResult() const
{ {
const RigReservoirCellResults* gridCellResults = m_reservoirView->currentGridCellResults(); const RimReservoirCellResultsCacher* gridCellResults = m_reservoirView->currentGridCellResults();
if (hasResult() && gridCellResults->timeStepCount(m_gridScalarResultIndex) == 1 ) if (hasResult() && gridCellResults->cellResults()->timeStepCount(m_gridScalarResultIndex) == 1 )
{ {
return true; return true;
} }
@@ -166,7 +166,7 @@ bool RimResultDefinition::hasResult() const
{ {
if (m_gridScalarResultIndex != cvf::UNDEFINED_SIZE_T) return true; if (m_gridScalarResultIndex != cvf::UNDEFINED_SIZE_T) return true;
const RigReservoirCellResults* gridCellResults = m_reservoirView->currentGridCellResults(); const RigReservoirCellResults* gridCellResults = m_reservoirView->currentGridCellResults()->cellResults();
if (gridCellResults) if (gridCellResults)
{ {
m_gridScalarResultIndex = gridCellResults->findScalarResultIndex(resultType(), resultVariable()); m_gridScalarResultIndex = gridCellResults->findScalarResultIndex(resultType(), resultVariable());
@@ -182,7 +182,7 @@ bool RimResultDefinition::hasResult() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimResultDefinition::hasDynamicResult() const bool RimResultDefinition::hasDynamicResult() const
{ {
const RigReservoirCellResults* gridCellResults = m_reservoirView->currentGridCellResults(); const RigReservoirCellResults* gridCellResults = m_reservoirView->currentGridCellResults()->cellResults();
if (hasResult() && gridCellResults->timeStepCount(m_gridScalarResultIndex) > 1 ) if (hasResult() && gridCellResults->timeStepCount(m_gridScalarResultIndex) > 1 )
return true; return true;
else else

25
ApplicationCode/ProjectDataModel/RimResultReservoir.cpp
View File

@@ -52,7 +52,7 @@ bool RimResultReservoir::openEclipseGridFile()
progInfo.setProgressDescription("Open Grid File"); progInfo.setProgressDescription("Open Grid File");
progInfo.setNextProgressIncrement(48); progInfo.setNextProgressIncrement(48);
// Early exit if reservoir data is created // Early exit if reservoir data is created
if (m_rigEclipseCase.notNull()) return true; if (this->reservoirData()) return true;
cvf::ref<RifReaderInterface> readerInterface; cvf::ref<RifReaderInterface> readerInterface;
@@ -60,8 +60,6 @@ bool RimResultReservoir::openEclipseGridFile()
{ {
readerInterface = this->createMockModel(this->caseName()); readerInterface = this->createMockModel(this->caseName());
m_rigEclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(readerInterface.p());
m_rigEclipseCase->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(readerInterface.p());
} }
else else
{ {
@@ -78,12 +76,15 @@ bool RimResultReservoir::openEclipseGridFile()
return false; return false;
} }
m_rigEclipseCase = eclipseCase; this->setReservoirData( eclipseCase.p() );
} }
results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(readerInterface.p());
results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(readerInterface.p());
progInfo.incrementProgress(); progInfo.incrementProgress();
CVF_ASSERT(m_rigEclipseCase.notNull()); CVF_ASSERT(this->reservoirData());
CVF_ASSERT(readerInterface.notNull()); CVF_ASSERT(readerInterface.notNull());
progInfo.setProgressDescription("Computing Case Cache"); progInfo.setProgressDescription("Computing Case Cache");
@@ -102,9 +103,6 @@ bool RimResultReservoir::openAndReadActiveCellData(RigEclipseCase* mainEclipseCa
if (caseName().contains("Result Mock Debug Model")) if (caseName().contains("Result Mock Debug Model"))
{ {
readerInterface = this->createMockModel(this->caseName()); readerInterface = this->createMockModel(this->caseName());
m_rigEclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(readerInterface.p());
m_rigEclipseCase->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(readerInterface.p());
} }
else else
{ {
@@ -127,13 +125,16 @@ bool RimResultReservoir::openAndReadActiveCellData(RigEclipseCase* mainEclipseCa
readerInterface->close(); readerInterface->close();
m_rigEclipseCase = eclipseCase; this->setReservoirData( eclipseCase.p() );
} }
CVF_ASSERT(m_rigEclipseCase.notNull()); results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(readerInterface.p());
results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(readerInterface.p());
CVF_ASSERT(this->reservoirData());
CVF_ASSERT(readerInterface.notNull()); CVF_ASSERT(readerInterface.notNull());
m_rigEclipseCase->computeCachedData(); reservoirData()->computeCachedData();
return true; return true;
} }
@@ -212,7 +213,7 @@ cvf::ref<RifReaderInterface> RimResultReservoir::createMockModel(QString modelNa
} }
m_rigEclipseCase = reservoir; this->setReservoirData( reservoir.p() );
return mockFileInterface.p(); return mockFileInterface.p();
} }

22
ApplicationCode/ProjectDataModel/RimStatisticalCalculation.cpp
View File

@@ -60,9 +60,9 @@ RimStatisticalCalculation::~RimStatisticalCalculation()
void RimStatisticalCalculation::setMainGrid(RigMainGrid* mainGrid) void RimStatisticalCalculation::setMainGrid(RigMainGrid* mainGrid)
{ {
CVF_ASSERT(mainGrid); CVF_ASSERT(mainGrid);
CVF_ASSERT(m_rigEclipseCase.notNull()); CVF_ASSERT(this->reservoirData());
m_rigEclipseCase->setMainGrid(mainGrid); reservoirData()->setMainGrid(mainGrid);
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -70,7 +70,7 @@ void RimStatisticalCalculation::setMainGrid(RigMainGrid* mainGrid)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimStatisticalCalculation::openEclipseGridFile() bool RimStatisticalCalculation::openEclipseGridFile()
{ {
if (m_rigEclipseCase.notNull()) return true; if (this->reservoirData()) return true;
cvf::ref<RigEclipseCase> eclipseCase = new RigEclipseCase; cvf::ref<RigEclipseCase> eclipseCase = new RigEclipseCase;
@@ -79,10 +79,10 @@ bool RimStatisticalCalculation::openEclipseGridFile()
return false; return false;
} }
m_rigEclipseCase = eclipseCase; this->setReservoirData( eclipseCase.p() );
m_rigEclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(m_readerInterface.p()); results(RifReaderInterface::MATRIX_RESULTS)->setReaderInterface(m_readerInterface.p());
m_rigEclipseCase->results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(m_readerInterface.p()); results(RifReaderInterface::FRACTURE_RESULTS)->setReaderInterface(m_readerInterface.p());
return true; return true;
} }
@@ -116,12 +116,12 @@ RimStatisticalCollection* RimStatisticalCalculation::parentStatisticalCollection
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimStatisticalCalculation::computeStatistics() void RimStatisticalCalculation::computeStatistics()
{ {
if (m_rigEclipseCase.isNull()) if (this->reservoirData() == NULL)
{ {
openEclipseGridFile(); openEclipseGridFile();
} }
cvf::Collection<RigEclipseCase> sourceCases; std::vector<RimReservoir*> sourceCases;
getSourceCases(sourceCases); getSourceCases(sourceCases);
@@ -132,7 +132,7 @@ void RimStatisticalCalculation::computeStatistics()
// The first source has been read completely from disk, and contains grid and meta data // The first source has been read completely from disk, and contains grid and meta data
// Use this information for all cases in the case group // Use this information for all cases in the case group
size_t timeStepCount = sourceCases.at(0)->results(RifReaderInterface::MATRIX_RESULTS)->maxTimeStepCount(); size_t timeStepCount = sourceCases.at(0)->results(RifReaderInterface::MATRIX_RESULTS)->cellResults()->maxTimeStepCount();
RigStatisticsConfig statisticsConfig; RigStatisticsConfig statisticsConfig;
@@ -183,7 +183,7 @@ void RimStatisticalCalculation::computeStatistics()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimStatisticalCalculation::getSourceCases(cvf::Collection<RigEclipseCase>& sourceCases) void RimStatisticalCalculation::getSourceCases(std::vector<RimReservoir*>& sourceCases)
{ {
RimIdenticalGridCaseGroup* gridCaseGroup = caseGroup(); RimIdenticalGridCaseGroup* gridCaseGroup = caseGroup();
if (gridCaseGroup) if (gridCaseGroup)
@@ -195,7 +195,7 @@ void RimStatisticalCalculation::getSourceCases(cvf::Collection<RigEclipseCase>&
CVF_ASSERT(gridCaseGroup->caseCollection->reservoirs[i]); CVF_ASSERT(gridCaseGroup->caseCollection->reservoirs[i]);
CVF_ASSERT(gridCaseGroup->caseCollection->reservoirs[i]->reservoirData()); CVF_ASSERT(gridCaseGroup->caseCollection->reservoirs[i]->reservoirData());
RigEclipseCase* sourceCase = gridCaseGroup->caseCollection->reservoirs[i]->reservoirData(); RimReservoir* sourceCase = gridCaseGroup->caseCollection->reservoirs[i];
sourceCases.push_back(sourceCase); sourceCases.push_back(sourceCase);
} }
} }

2
ApplicationCode/ProjectDataModel/RimStatisticalCalculation.h
View File

@@ -59,7 +59,7 @@ public:
private: private:
RimIdenticalGridCaseGroup* caseGroup(); RimIdenticalGridCaseGroup* caseGroup();
void getSourceCases(cvf::Collection<RigEclipseCase>& sourceCases); void getSourceCases(std::vector<RimReservoir*>& sourceCases);
private: private:
cvf::ref<RifReaderStatisticalCalculation> m_readerInterface; cvf::ref<RifReaderStatisticalCalculation> m_readerInterface;

3
ApplicationCode/ReservoirDataModel/ReservoirDataModel_UnitTests/CMakeLists.txt
View File

@@ -22,6 +22,9 @@ include_directories(
${ResInsight_SOURCE_DIR}/cafProjectDataModel ${ResInsight_SOURCE_DIR}/cafProjectDataModel
${ResInsight_SOURCE_DIR}/CommonCode ${ResInsight_SOURCE_DIR}/CommonCode
#Remove when RigStatistics is out
${ResInsight_SOURCE_DIR}/ApplicationCode/ModelVisualization
) )
# Populate the filenames into variable lists # Populate the filenames into variable lists

3
ApplicationCode/ReservoirDataModel/RigEclipseCase.cpp
View File

@@ -425,7 +425,7 @@ cvf::ref<cvf::StructGridScalarDataAccess> RigEclipseCase::dataAccessObject(const
return NULL; return NULL;
} }
/*
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -438,3 +438,4 @@ void RigEclipseCase::closeReaderInterface()
readerInterface->close(); readerInterface->close();
} }
} }
*/

2
ApplicationCode/ReservoirDataModel/RigEclipseCase.h
View File

@@ -68,7 +68,7 @@ public:
bool findSharedSourceFace(cvf::StructGridInterface::FaceType& sharedSourceFace, const RigWellResultCell& sourceWellCellResult, const RigWellResultCell& otherWellCellResult) const; bool findSharedSourceFace(cvf::StructGridInterface::FaceType& sharedSourceFace, const RigWellResultCell& sourceWellCellResult, const RigWellResultCell& otherWellCellResult) const;
void computeCachedData(); void computeCachedData();
void closeReaderInterface(); //void closeReaderInterface();
private: private:
void computeActiveCellData(); void computeActiveCellData();

374
ApplicationCode/ReservoirDataModel/RigReservoirCellResults.cpp
View File

@@ -280,146 +280,6 @@ double RigReservoirCellResults::cellScalarResult( size_t scalarResultIndex, size
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigReservoirCellResults::findOrLoadScalarResultForTimeStep(RimDefines::ResultCatType type, const QString& resultName, size_t timeStepIndex)
{
// Special handling for SOIL
if (type == RimDefines::DYNAMIC_NATIVE && resultName.toUpper() == "SOIL")
{
loadOrComputeSOILForTimeStep(timeStepIndex);
}
size_t resultGridIndex = cvf::UNDEFINED_SIZE_T;
resultGridIndex = findScalarResultIndex(type, resultName);
if (resultGridIndex == cvf::UNDEFINED_SIZE_T) return cvf::UNDEFINED_SIZE_T;
if (type == RimDefines::GENERATED)
{
return cvf::UNDEFINED_SIZE_T;
}
if (m_readerInterface.notNull())
{
size_t timeStepCount = m_resultInfos[resultGridIndex].m_timeStepDates.size();
bool resultLoadingSucess = true;
if (type == RimDefines::DYNAMIC_NATIVE && timeStepCount > 0)
{
m_cellScalarResults[resultGridIndex].resize(timeStepCount);
std::vector<double>& values = m_cellScalarResults[resultGridIndex][timeStepIndex];
if (values.size() == 0)
{
if (!m_readerInterface->dynamicResult(resultName, RifReaderInterface::MATRIX_RESULTS, timeStepIndex, &values))
{
resultLoadingSucess = false;
}
}
}
else if (type == RimDefines::STATIC_NATIVE)
{
m_cellScalarResults[resultGridIndex].resize(1);
std::vector<double>& values = m_cellScalarResults[resultGridIndex][0];
if (!m_readerInterface->staticResult(resultName, RifReaderInterface::MATRIX_RESULTS, &values))
{
resultLoadingSucess = false;
}
}
if (!resultLoadingSucess)
{
// Error logging
CVF_ASSERT(false);
}
}
return resultGridIndex;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigReservoirCellResults::findOrLoadScalarResult(RimDefines::ResultCatType type, const QString& resultName)
{
size_t resultGridIndex = cvf::UNDEFINED_SIZE_T;
resultGridIndex = findScalarResultIndex(type, resultName);
if (resultGridIndex == cvf::UNDEFINED_SIZE_T) return cvf::UNDEFINED_SIZE_T;
if (cellScalarResults(resultGridIndex).size()) return resultGridIndex;
if (type == RimDefines::GENERATED)
{
return cvf::UNDEFINED_SIZE_T;
}
if (m_readerInterface.notNull())
{
// Add one more result to result container
size_t timeStepCount = m_resultInfos[resultGridIndex].m_timeStepDates.size();
bool resultLoadingSucess = true;
if (type == RimDefines::DYNAMIC_NATIVE && timeStepCount > 0)
{
m_cellScalarResults[resultGridIndex].resize(timeStepCount);
size_t i;
for (i = 0; i < timeStepCount; i++)
{
std::vector<double>& values = m_cellScalarResults[resultGridIndex][i];
if (!m_readerInterface->dynamicResult(resultName, RifReaderInterface::MATRIX_RESULTS, i, &values))
{
resultLoadingSucess = false;
}
}
}
else if (type == RimDefines::STATIC_NATIVE)
{
m_cellScalarResults[resultGridIndex].resize(1);
std::vector<double>& values = m_cellScalarResults[resultGridIndex][0];
if (!m_readerInterface->staticResult(resultName, RifReaderInterface::MATRIX_RESULTS, &values))
{
resultLoadingSucess = false;
}
}
if (!resultLoadingSucess)
{
// Remove last scalar result because loading of result failed
m_cellScalarResults[resultGridIndex].clear();
}
}
return resultGridIndex;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirCellResults::setReaderInterface(RifReaderInterface* readerInterface)
{
m_readerInterface = readerInterface;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifReaderInterface* RigReservoirCellResults::readerInterface()
{
return m_readerInterface.p();
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -464,234 +324,6 @@ size_t RigReservoirCellResults::findScalarResultIndex(const QString& resultName)
return scalarResultIndex; return scalarResultIndex;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirCellResults::loadOrComputeSOIL()
{
for (size_t timeStepIdx = 0; timeStepIdx < maxTimeStepCount(); timeStepIdx++)
{
loadOrComputeSOILForTimeStep(timeStepIdx);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirCellResults::loadOrComputeSOILForTimeStep(size_t timeStepIndex)
{
size_t scalarIndexSWAT = findOrLoadScalarResultForTimeStep(RimDefines::DYNAMIC_NATIVE, "SWAT", timeStepIndex);
size_t scalarIndexSGAS = findOrLoadScalarResultForTimeStep(RimDefines::DYNAMIC_NATIVE, "SGAS", timeStepIndex);
// Early exit if none of SWAT or SGAS is present
if (scalarIndexSWAT == cvf::UNDEFINED_SIZE_T && scalarIndexSGAS == cvf::UNDEFINED_SIZE_T)
{
return;
}
size_t soilResultValueCount = 0;
size_t soilTimeStepCount = 0;
std::vector<double>* swatForTimeStep = NULL;
std::vector<double>* sgasForTimeStep = NULL;
if (scalarIndexSWAT != cvf::UNDEFINED_SIZE_T)
{
swatForTimeStep = &(cellScalarResults(scalarIndexSWAT, timeStepIndex));
if (swatForTimeStep->size() == 0)
{
swatForTimeStep = NULL;
}
else
{
soilResultValueCount = swatForTimeStep->size();
soilTimeStepCount = m_resultInfos[scalarIndexSWAT].m_timeStepDates.size();
}
}
if (scalarIndexSGAS != cvf::UNDEFINED_SIZE_T)
{
sgasForTimeStep = &(cellScalarResults(scalarIndexSGAS, timeStepIndex));
if (sgasForTimeStep->size() == 0)
{
sgasForTimeStep = NULL;
}
else
{
soilResultValueCount = qMax(soilResultValueCount, sgasForTimeStep->size());
size_t sgasTimeStepCount = m_resultInfos[scalarIndexSGAS].m_timeStepDates.size();
soilTimeStepCount = qMax(soilTimeStepCount, sgasTimeStepCount);
}
}
size_t soilResultGridIndex = findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SOIL");
if (soilResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
soilResultGridIndex = addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, "SOIL");
CVF_ASSERT(soilResultGridIndex != cvf::UNDEFINED_SIZE_T);
m_cellScalarResults[soilResultGridIndex].resize(soilTimeStepCount);
for (size_t timeStepIdx = 0; timeStepIdx < soilTimeStepCount; timeStepIdx++)
{
m_cellScalarResults[soilResultGridIndex][timeStepIdx].resize(soilResultValueCount);
}
}
std::vector<double>& soilForTimeStep = cellScalarResults(soilResultGridIndex, timeStepIndex);
#pragma omp parallel for
for (int idx = 0; idx < static_cast<int>(soilResultValueCount); idx++)
{
double soilValue = 1.0;
if (sgasForTimeStep)
{
soilValue -= sgasForTimeStep->at(idx);
}
if (swatForTimeStep)
{
soilValue -= swatForTimeStep->at(idx);
}
soilForTimeStep[idx] = soilValue;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigReservoirCellResults::computeDepthRelatedResults()
{
size_t depthResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DEPTH");
size_t dxResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DX");
size_t dyResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DY");
size_t dzResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "DZ");
size_t topsResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "TOPS");
size_t bottomResultGridIndex = findOrLoadScalarResult(RimDefines::STATIC_NATIVE, "BOTTOM");
bool computeDepth = false;
bool computeDx = false;
bool computeDy = false;
bool computeDz = false;
bool computeTops = false;
bool computeBottom = false;
size_t resultValueCount = m_ownerMainGrid->cells().size();
if (depthResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
depthResultGridIndex = addStaticScalarResult(RimDefines::STATIC_NATIVE, "DEPTH", resultValueCount);
computeDepth = true;
}
if (dxResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
dxResultGridIndex = addStaticScalarResult(RimDefines::STATIC_NATIVE, "DX", resultValueCount);
computeDx = true;
}
if (dyResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
dyResultGridIndex = addStaticScalarResult(RimDefines::STATIC_NATIVE, "DY", resultValueCount);
computeDy = true;
}
if (dzResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
dzResultGridIndex = addStaticScalarResult(RimDefines::STATIC_NATIVE, "DZ", resultValueCount);
computeDz = true;
}
if (topsResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
topsResultGridIndex = addStaticScalarResult(RimDefines::STATIC_NATIVE, "TOPS", resultValueCount);
computeTops = true;
}
if (bottomResultGridIndex == cvf::UNDEFINED_SIZE_T)
{
bottomResultGridIndex = addStaticScalarResult(RimDefines::STATIC_NATIVE, "BOTTOM", resultValueCount);
computeBottom = true;
}
std::vector< std::vector<double> >& depth = cellScalarResults(depthResultGridIndex);
std::vector< std::vector<double> >& dx = cellScalarResults(dxResultGridIndex);
std::vector< std::vector<double> >& dy = cellScalarResults(dyResultGridIndex);
std::vector< std::vector<double> >& dz = cellScalarResults(dzResultGridIndex);
std::vector< std::vector<double> >& tops = cellScalarResults(topsResultGridIndex);
std::vector< std::vector<double> >& bottom = cellScalarResults(bottomResultGridIndex);
size_t cellIdx = 0;
for (cellIdx = 0; cellIdx < m_ownerMainGrid->cells().size(); cellIdx++)
{
const RigCell& cell = m_ownerMainGrid->cells()[cellIdx];
if (computeDepth)
{
depth[0][cellIdx] = cvf::Math::abs(cell.center().z());
}
if (computeDx)
{
cvf::Vec3d cellWidth = cell.faceCenter(cvf::StructGridInterface::NEG_I) - cell.faceCenter(cvf::StructGridInterface::POS_I);
dx[0][cellIdx] = cvf::Math::abs(cellWidth.x());
}
if (computeDy)
{
cvf::Vec3d cellWidth = cell.faceCenter(cvf::StructGridInterface::NEG_J) - cell.faceCenter(cvf::StructGridInterface::POS_J);
dy[0][cellIdx] = cvf::Math::abs(cellWidth.y());
}
if (computeDz)
{
cvf::Vec3d cellWidth = cell.faceCenter(cvf::StructGridInterface::NEG_K) - cell.faceCenter(cvf::StructGridInterface::POS_K);
dz[0][cellIdx] = cvf::Math::abs(cellWidth.z());
}
if (computeTops)
{
tops[0][cellIdx] = cvf::Math::abs(cell.faceCenter(cvf::StructGridInterface::NEG_K).z());
}
if (computeBottom)
{
bottom[0][cellIdx] = cvf::Math::abs(cell.faceCenter(cvf::StructGridInterface::POS_K).z());
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigReservoirCellResults::findOrLoadScalarResult(const QString& resultName)
{
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T;
scalarResultIndex = this->findOrLoadScalarResult(RimDefines::STATIC_NATIVE, resultName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = this->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, resultName);
}
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = this->findScalarResultIndex(RimDefines::GENERATED, resultName);
}
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = this->findScalarResultIndex(RimDefines::INPUT_PROPERTY, resultName);
}
return scalarResultIndex;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Adds an empty scalar set, and returns the scalarResultIndex to it. /// Adds an empty scalar set, and returns the scalarResultIndex to it.
/// if resultName already exists, it returns the scalarResultIndex to the existing result. /// if resultName already exists, it returns the scalarResultIndex to the existing result.
@@ -793,6 +425,10 @@ void RigReservoirCellResults::setTimeStepDates(size_t scalarResultIndex, const s
CVF_ASSERT(scalarResultIndex < m_resultInfos.size() ); CVF_ASSERT(scalarResultIndex < m_resultInfos.size() );
m_resultInfos[scalarResultIndex].m_timeStepDates = dates; m_resultInfos[scalarResultIndex].m_timeStepDates = dates;
// We need this. But not yet ...
//std::vector< std::vector<double> >& dataValues = this->cellScalarResults(scalarResultIndex);
//dataValues.resize(dates.size());
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@@ -800,7 +436,7 @@ void RigReservoirCellResults::setTimeStepDates(size_t scalarResultIndex, const s
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
size_t RigReservoirCellResults::maxTimeStepCount() const size_t RigReservoirCellResults::maxTimeStepCount() const
{ {
int maxTsCount = 0; size_t maxTsCount = 0;
std::vector<ResultInfo>::const_iterator it; std::vector<ResultInfo>::const_iterator it;
for (it = m_resultInfos.begin(); it != m_resultInfos.end(); it++) for (it = m_resultInfos.begin(); it != m_resultInfos.end(); it++)

20
ApplicationCode/ReservoirDataModel/RigReservoirCellResults.h
View File

@@ -35,8 +35,8 @@ class RigReservoirCellResults : public cvf::Object
public: public:
RigReservoirCellResults(RigMainGrid* ownerGrid); RigReservoirCellResults(RigMainGrid* ownerGrid);
void setReaderInterface(RifReaderInterface* readerInterface); //void setReaderInterface(RifReaderInterface* readerInterface);
RifReaderInterface* readerInterface(); //RifReaderInterface* readerInterface();
// Max and min values of the results // Max and min values of the results
void recalculateMinMax(size_t scalarResultIndex); void recalculateMinMax(size_t scalarResultIndex);
@@ -58,20 +58,16 @@ public:
void setTimeStepDates(size_t scalarResultIndex, const std::vector<QDateTime>& dates); void setTimeStepDates(size_t scalarResultIndex, const std::vector<QDateTime>& dates);
// Find or create a slot for the results // Find or create a slot for the results
size_t findOrLoadScalarResultForTimeStep(RimDefines::ResultCatType type, const QString& resultName, size_t timeStepIndex);
size_t findOrLoadScalarResult(RimDefines::ResultCatType type, const QString& resultName);
size_t findOrLoadScalarResult(const QString& resultName); ///< Simplified search. Assumes unique names across types.
size_t findScalarResultIndex(RimDefines::ResultCatType type, const QString& resultName) const; size_t findScalarResultIndex(RimDefines::ResultCatType type, const QString& resultName) const;
size_t findScalarResultIndex(const QString& resultName) const; size_t findScalarResultIndex(const QString& resultName) const;
size_t addEmptyScalarResult(RimDefines::ResultCatType type, const QString& resultName); size_t addEmptyScalarResult(RimDefines::ResultCatType type, const QString& resultName);
QString makeResultNameUnique(const QString& resultNameProposal) const; QString makeResultNameUnique(const QString& resultNameProposal) const;
void removeResult(const QString& resultName); void removeResult(const QString& resultName);
void clearAllResults(); void clearAllResults();
void loadOrComputeSOIL();
void loadOrComputeSOILForTimeStep(size_t timeStepIndex);
void computeDepthRelatedResults();
// Access the results data // Access the results data
const std::vector< std::vector<double> > & cellScalarResults(size_t scalarResultIndex) const; const std::vector< std::vector<double> > & cellScalarResults(size_t scalarResultIndex) const;
@@ -97,8 +93,10 @@ public:
const std::vector<ResultInfo>& infoForEachResultIndex() { return m_resultInfos;} const std::vector<ResultInfo>& infoForEachResultIndex() { return m_resultInfos;}
private: public:
size_t addStaticScalarResult(RimDefines::ResultCatType type, const QString& resultName, size_t resultValueCount); size_t addStaticScalarResult(RimDefines::ResultCatType type,
const QString& resultName,
size_t resultValueCount);
private: private:
std::vector< std::vector< std::vector<double> > > m_cellScalarResults; ///< Scalar results on the complete reservoir for each Result index (ResultVariable) and timestep std::vector< std::vector< std::vector<double> > > m_cellScalarResults; ///< Scalar results on the complete reservoir for each Result index (ResultVariable) and timestep
@@ -113,7 +111,7 @@ private:
private: private:
std::vector<ResultInfo> m_resultInfos; std::vector<ResultInfo> m_resultInfos;
cvf::ref<RifReaderInterface> m_readerInterface;
RigMainGrid* m_ownerMainGrid; RigMainGrid* m_ownerMainGrid;
}; };

45
ApplicationCode/ReservoirDataModel/RigStatistics.cpp
View File

@@ -18,7 +18,11 @@
#include "RigStatistics.h" #include "RigStatistics.h"
#include "RigReservoirCellResults.h" #include "RigReservoirCellResults.h"
#include "RimReservoirView.h"
#include "RimReservoir.h"
#include "RigEclipseCase.h"
//#include "RigEclipseCase.h"
#include <QDebug> #include <QDebug>
#include "cafProgressInfo.h" #include "cafProgressInfo.h"
@@ -30,7 +34,8 @@ void RigStatistics::addNamedResult(RigReservoirCellResults* destinationCellResul
// Use time step dates from first result in first source case // Use time step dates from first result in first source case
CVF_ASSERT(m_sourceCases.size() > 0); CVF_ASSERT(m_sourceCases.size() > 0);
std::vector<QDateTime> sourceTimeStepDates = m_sourceCases[0]->results(RifReaderInterface::MATRIX_RESULTS)->timeStepDates(0); std::vector<QDateTime> sourceTimeStepDates = m_sourceCases[0]->results(RifReaderInterface::MATRIX_RESULTS)->cellResults()->timeStepDates(0);
size_t destinationScalarResultIndex = destinationCellResults->addEmptyScalarResult(resultType, resultName); size_t destinationScalarResultIndex = destinationCellResults->addEmptyScalarResult(resultType, resultName);
CVF_ASSERT(destinationScalarResultIndex != cvf::UNDEFINED_SIZE_T); CVF_ASSERT(destinationScalarResultIndex != cvf::UNDEFINED_SIZE_T);
@@ -38,6 +43,7 @@ void RigStatistics::addNamedResult(RigReservoirCellResults* destinationCellResul
std::vector< std::vector<double> >& dataValues = destinationCellResults->cellScalarResults(destinationScalarResultIndex); std::vector< std::vector<double> >& dataValues = destinationCellResults->cellScalarResults(destinationScalarResultIndex);
dataValues.resize(sourceTimeStepDates.size()); dataValues.resize(sourceTimeStepDates.size());
// Initializes the size of the destination dataset to active union cell count // Initializes the size of the destination dataset to active union cell count
for (int i = 0; i < sourceTimeStepDates.size(); i++) for (int i = 0; i < sourceTimeStepDates.size(); i++)
{ {
@@ -58,7 +64,7 @@ void RigStatistics::computeActiveCellUnion()
CVF_ASSERT(m_destinationCase); CVF_ASSERT(m_destinationCase);
RigMainGrid* mainGrid = m_sourceCases[0]->mainGrid(); RigMainGrid* mainGrid = m_sourceCases[0]->reservoirData()->mainGrid();
CVF_ASSERT(mainGrid); CVF_ASSERT(mainGrid);
m_destinationCase->activeCellInfo(RifReaderInterface::MATRIX_RESULTS)->setGlobalCellCount(mainGrid->cells().size()); m_destinationCase->activeCellInfo(RifReaderInterface::MATRIX_RESULTS)->setGlobalCellCount(mainGrid->cells().size());
@@ -84,7 +90,7 @@ void RigStatistics::computeActiveCellUnion()
if (activeM[localGridCellIdx] == 0) if (activeM[localGridCellIdx] == 0)
{ {
if (m_sourceCases[caseIdx]->activeCellInfo(RifReaderInterface::MATRIX_RESULTS)->isActiveInMatrixModel(globalCellIdx)) if (m_sourceCases[caseIdx]->reservoirData()->activeCellInfo(RifReaderInterface::MATRIX_RESULTS)->isActiveInMatrixModel(globalCellIdx))
{ {
activeM[localGridCellIdx] = 1; activeM[localGridCellIdx] = 1;
} }
@@ -92,7 +98,7 @@ void RigStatistics::computeActiveCellUnion()
if (activeF[localGridCellIdx] == 0) if (activeF[localGridCellIdx] == 0)
{ {
if (m_sourceCases[caseIdx]->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS)->isActiveInMatrixModel(globalCellIdx)) if (m_sourceCases[caseIdx]->reservoirData()->activeCellInfo(RifReaderInterface::FRACTURE_RESULTS)->isActiveInMatrixModel(globalCellIdx))
{ {
activeF[localGridCellIdx] = 1; activeF[localGridCellIdx] = 1;
} }
@@ -143,20 +149,20 @@ void RigStatistics::buildSourceMetaData(RimDefines::ResultCatType resultType, co
{ {
if (m_sourceCases.size() == 0) return; if (m_sourceCases.size() == 0) return;
std::vector<QDateTime> timeStepDates = m_sourceCases[0]->results(RifReaderInterface::MATRIX_RESULTS)->timeStepDates(0); std::vector<QDateTime> timeStepDates = m_sourceCases[0]->results(RifReaderInterface::MATRIX_RESULTS)->cellResults()->timeStepDates(0);
for (size_t caseIdx = 1; caseIdx < m_sourceCases.size(); caseIdx++) for (size_t caseIdx = 1; caseIdx < m_sourceCases.size(); caseIdx++)
{ {
RigEclipseCase* eclipseCase = m_sourceCases.at(caseIdx); RigEclipseCase* eclipseCase = m_sourceCases.at(caseIdx)->reservoirData();
RigReservoirCellResults* matrixResults = eclipseCase->results(RifReaderInterface::MATRIX_RESULTS); RimReservoirCellResultsCacher* matrixResults = m_sourceCases[caseIdx]->results(RifReaderInterface::MATRIX_RESULTS);
size_t scalarResultIndex = matrixResults->findOrLoadScalarResult(resultType, resultName); size_t scalarResultIndex = matrixResults->findOrLoadScalarResult(resultType, resultName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T) if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{ {
size_t scalarResultIndex = matrixResults->addEmptyScalarResult(resultType, resultName); size_t scalarResultIndex = matrixResults->cellResults()->addEmptyScalarResult(resultType, resultName);
matrixResults->setTimeStepDates(scalarResultIndex, timeStepDates); matrixResults->cellResults()->setTimeStepDates(scalarResultIndex, timeStepDates);
std::vector< std::vector<double> >& dataValues = matrixResults->cellScalarResults(scalarResultIndex); std::vector< std::vector<double> >& dataValues = matrixResults->cellResults()->cellScalarResults(scalarResultIndex);
dataValues.resize(timeStepDates.size()); dataValues.resize(timeStepDates.size());
} }
} }
@@ -183,13 +189,13 @@ void RigStatistics::evaluateStatistics(const QList<QPair<RimDefines::ResultCatTy
// Build SGAS/SWAT meta data, SOIL is automatically generated as part of RigReservoirCellResults::findOrLoadScalarResultForTimeStep // Build SGAS/SWAT meta data, SOIL is automatically generated as part of RigReservoirCellResults::findOrLoadScalarResultForTimeStep
if (resultName.toUpper() == "SOIL") if (resultName.toUpper() == "SOIL")
{ {
size_t swatIndex = m_sourceCases.at(0)->results(RifReaderInterface::MATRIX_RESULTS)->findScalarResultIndex(resultType, "SWAT"); size_t swatIndex = m_sourceCases.at(0)->results(RifReaderInterface::MATRIX_RESULTS)->cellResults()->findScalarResultIndex(resultType, "SWAT");
if (swatIndex != cvf::UNDEFINED_SIZE_T) if (swatIndex != cvf::UNDEFINED_SIZE_T)
{ {
buildSourceMetaData(resultType, "SWAT"); buildSourceMetaData(resultType, "SWAT");
} }
size_t sgasIndex = m_sourceCases.at(0)->results(RifReaderInterface::MATRIX_RESULTS)->findScalarResultIndex(resultType, "SGAS"); size_t sgasIndex = m_sourceCases.at(0)->results(RifReaderInterface::MATRIX_RESULTS)->cellResults()->findScalarResultIndex(resultType, "SGAS");
if (sgasIndex != cvf::UNDEFINED_SIZE_T) if (sgasIndex != cvf::UNDEFINED_SIZE_T)
{ {
buildSourceMetaData(resultType, "SGAS"); buildSourceMetaData(resultType, "SGAS");
@@ -248,11 +254,11 @@ void RigStatistics::evaluateStatistics(const QList<QPair<RimDefines::ResultCatTy
cvf::Collection<cvf::StructGridScalarDataAccess> dataAccesObjectList; cvf::Collection<cvf::StructGridScalarDataAccess> dataAccesObjectList;
for (size_t caseIdx = 0; caseIdx < m_sourceCases.size(); caseIdx++) for (size_t caseIdx = 0; caseIdx < m_sourceCases.size(); caseIdx++)
{ {
RigEclipseCase* eclipseCase = m_sourceCases.at(caseIdx); RimReservoir* eclipseCase = m_sourceCases.at(caseIdx);
size_t scalarResultIndex = eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResultForTimeStep(resultType, resultName, dataAccessTimeStepIndex); size_t scalarResultIndex = eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResultForTimeStep(resultType, resultName, dataAccessTimeStepIndex);
cvf::ref<cvf::StructGridScalarDataAccess> dataAccessObject = eclipseCase->dataAccessObject(grid, RifReaderInterface::MATRIX_RESULTS, dataAccessTimeStepIndex, scalarResultIndex); cvf::ref<cvf::StructGridScalarDataAccess> dataAccessObject = eclipseCase->reservoirData()->dataAccessObject(grid, RifReaderInterface::MATRIX_RESULTS, dataAccessTimeStepIndex, scalarResultIndex);
if (dataAccessObject.notNull()) if (dataAccessObject.notNull())
{ {
dataAccesObjectList.push_back(dataAccessObject.p()); dataAccesObjectList.push_back(dataAccessObject.p());
@@ -355,13 +361,13 @@ void RigStatistics::evaluateStatistics(const QList<QPair<RimDefines::ResultCatTy
for (size_t caseIdx = 0; caseIdx < m_sourceCases.size(); caseIdx++) for (size_t caseIdx = 0; caseIdx < m_sourceCases.size(); caseIdx++)
{ {
RigEclipseCase* eclipseCase = m_sourceCases.at(caseIdx); RimReservoir* eclipseCase = m_sourceCases.at(caseIdx);
// When one time step is completed, close all result files. // When one time step is completed, close all result files.
// Microsoft note: On Windows, the maximum number of files open at the same time is 512 // Microsoft note: On Windows, the maximum number of files open at the same time is 512
// http://msdn.microsoft.com/en-us/library/kdfaxaay%28vs.71%29.aspx // http://msdn.microsoft.com/en-us/library/kdfaxaay%28vs.71%29.aspx
// //
eclipseCase->closeReaderInterface(); eclipseCase->results(RifReaderInterface::MATRIX_RESULTS)->readerInterface()->close();
} }
info.setProgress(timeIndicesIdx); info.setProgress(timeIndicesIdx);
@@ -378,7 +384,7 @@ void RigStatistics::debugOutput(RimDefines::ResultCatType resultType, const QStr
qDebug() << resultName << "timeIdx : " << timeStepIdx; qDebug() << resultName << "timeIdx : " << timeStepIdx;
size_t scalarResultIndex = m_destinationCase->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(resultType, resultName); size_t scalarResultIndex = m_destinationCase->results(RifReaderInterface::MATRIX_RESULTS)->findScalarResultIndex(resultType, resultName);
cvf::ref<cvf::StructGridScalarDataAccess> dataAccessObject = m_destinationCase->dataAccessObject(m_destinationCase->mainGrid(), RifReaderInterface::MATRIX_RESULTS, timeStepIdx, scalarResultIndex); cvf::ref<cvf::StructGridScalarDataAccess> dataAccessObject = m_destinationCase->dataAccessObject(m_destinationCase->mainGrid(), RifReaderInterface::MATRIX_RESULTS, timeStepIdx, scalarResultIndex);
if (dataAccessObject.isNull()) return; if (dataAccessObject.isNull()) return;
@@ -392,7 +398,8 @@ void RigStatistics::debugOutput(RimDefines::ResultCatType resultType, const QStr
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigStatistics::RigStatistics(cvf::Collection<RigEclipseCase>& sourceCases, const std::vector<size_t>& timeStepIndices, const RigStatisticsConfig& statisticsConfig, RigEclipseCase* destinationCase) : m_sourceCases(sourceCases), RigStatistics::RigStatistics(const std::vector<RimReservoir*>& sourceCases, const std::vector<size_t>& timeStepIndices, const RigStatisticsConfig& statisticsConfig, RigEclipseCase* destinationCase)
: m_sourceCases(sourceCases),
m_statisticsConfig(statisticsConfig), m_statisticsConfig(statisticsConfig),
m_destinationCase(destinationCase), m_destinationCase(destinationCase),
m_globalCellCount(0), m_globalCellCount(0),
@@ -400,7 +407,7 @@ RigStatistics::RigStatistics(cvf::Collection<RigEclipseCase>& sourceCases, const
{ {
if (sourceCases.size() > 0) if (sourceCases.size() > 0)
{ {
m_globalCellCount = sourceCases[0]->mainGrid()->cells().size(); m_globalCellCount = sourceCases[0]->reservoirData()->mainGrid()->cells().size();
} }
CVF_ASSERT(m_destinationCase); CVF_ASSERT(m_destinationCase);

11
ApplicationCode/ReservoirDataModel/RigStatistics.h
View File

@@ -22,12 +22,17 @@
#include "cvfObject.h" #include "cvfObject.h"
#include "cvfCollection.h" #include "cvfCollection.h"
#include "RigEclipseCase.h"
#include <vector> #include <vector>
#include <math.h> #include <math.h>
#include <QPair> #include <QPair>
#include "RimDefines.h"
class RimReservoir;
class RigEclipseCase;
class RigReservoirCellResults;
class RigStatisticsEvaluator class RigStatisticsEvaluator
{ {
@@ -124,7 +129,7 @@ public:
class RigStatistics class RigStatistics
{ {
public: public:
RigStatistics(cvf::Collection<RigEclipseCase>& sourceCases, RigStatistics(const std::vector<RimReservoir*>& sourceCases,
const std::vector<size_t>& timeStepIndices, const std::vector<size_t>& timeStepIndices,
const RigStatisticsConfig& statisticsConfig, const RigStatisticsConfig& statisticsConfig,
RigEclipseCase* destinationCase); RigEclipseCase* destinationCase);
@@ -140,7 +145,7 @@ private:
void buildSourceMetaData(RimDefines::ResultCatType resultType, const QString& resultName); void buildSourceMetaData(RimDefines::ResultCatType resultType, const QString& resultName);
private: private:
cvf::Collection<RigEclipseCase> m_sourceCases; std::vector<RimReservoir*> m_sourceCases;
std::vector<size_t> m_timeStepIndices; std::vector<size_t> m_timeStepIndices;
size_t m_globalCellCount; size_t m_globalCellCount;

8
ApplicationCode/SocketInterface/RiaSocketServer.cpp
View File

@@ -280,18 +280,18 @@ void RiaSocketServer::readCommandFromOctave()
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T; size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T;
std::vector< std::vector<double> >* scalarResultFrames = NULL; std::vector< std::vector<double> >* scalarResultFrames = NULL;
if (reservoir && reservoir->reservoirData() && reservoir->reservoirData()->results(RifReaderInterface::MATRIX_RESULTS)) if (reservoir && reservoir->results(RifReaderInterface::MATRIX_RESULTS))
{ {
scalarResultIndex = reservoir->reservoirData()->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(propertyName); scalarResultIndex = reservoir->results(RifReaderInterface::MATRIX_RESULTS)->findOrLoadScalarResult(propertyName);
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T && isSetProperty) if (scalarResultIndex == cvf::UNDEFINED_SIZE_T && isSetProperty)
{ {
scalarResultIndex = reservoir->reservoirData()->results(RifReaderInterface::MATRIX_RESULTS)->addEmptyScalarResult(RimDefines::GENERATED, propertyName); scalarResultIndex = reservoir->results(RifReaderInterface::MATRIX_RESULTS)->cellResults()->addEmptyScalarResult(RimDefines::GENERATED, propertyName);
} }
if (scalarResultIndex != cvf::UNDEFINED_SIZE_T) if (scalarResultIndex != cvf::UNDEFINED_SIZE_T)
{ {
scalarResultFrames = &(reservoir->reservoirData()->results(RifReaderInterface::MATRIX_RESULTS)->cellScalarResults(scalarResultIndex)); scalarResultFrames = &(reservoir->results(RifReaderInterface::MATRIX_RESULTS)->cellResults()->cellScalarResults(scalarResultIndex));
m_currentScalarIndex = scalarResultIndex; m_currentScalarIndex = scalarResultIndex;
m_currentPropertyName = propertyName; m_currentPropertyName = propertyName;
} }

2
ApplicationCode/UserInterface/RIMainWindow.cpp
View File

@@ -546,7 +546,7 @@ void RIMainWindow::refreshAnimationActions()
|| app->activeReservoirView()->propertyFilterCollection()->hasActiveDynamicFilters() || app->activeReservoirView()->propertyFilterCollection()->hasActiveDynamicFilters()
|| app->activeReservoirView()->wellCollection()->hasVisibleWellPipes()) || app->activeReservoirView()->wellCollection()->hasVisibleWellPipes())
{ {
std::vector<QDateTime> timeStepDates = app->activeReservoirView()->currentGridCellResults()->timeStepDates(0); std::vector<QDateTime> timeStepDates = app->activeReservoirView()->currentGridCellResults()->cellResults()->timeStepDates(0);
bool showHoursAndMinutes = false; bool showHoursAndMinutes = false;
for (int i = 0; i < timeStepDates.size(); i++) for (int i = 0; i < timeStepDates.size(); i++)
{ {