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

#1645 Load dynamic NNC results from restart file

Browse Source
This commit is contained in:
Bjørnar Grip Fjær 2017-06-26 10:25:08 +02:00
parent 7b7af2b197
commit de414c4277
21 changed files with 423 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationCode/FileInterface/RifEclipseRestartDataAccess.h
View File

@ -99,11 +99,13 @@ public:
virtual void setTimeSteps(const std::vector<QDateTime>& timeSteps) {};
virtual size_t timeStepCount() = 0;
virtual void timeSteps(std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart) = 0;
virtual std::vector<int> reportNumbers() = 0;
virtual std::vector<int> reportNumbers() = 0;
virtual void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts) = 0;
virtual bool results(const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values) = 0;
virtual bool dynamicNNCResults(const ecl_grid_type* grid, size_t timeStep, std::vector<double>* waterFlux, std::vector<double>* oilFlux, std::vector<double>* gasFlux) = 0;
virtual void readWellData(well_info_type * well_info, bool importCompleteMswData) = 0;
virtual int readUnitsType() = 0;
};

47
ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.cpp
View File

@ -22,6 +22,9 @@
#include "RifEclipseOutputFileTools.h"
#include "cafProgressInfo.h"
#include "ert/ecl/ecl_file.h"
#include "ert/ecl/ecl_nnc_geometry.h"
#include "ert/ecl/ecl_nnc_data.h"
//--------------------------------------------------------------------------------------------------
/// Constructor
@ -211,6 +214,50 @@ bool RifEclipseRestartFilesetAccess::results(const QString& resultName, size_t t
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseRestartFilesetAccess::dynamicNNCResults(const ecl_grid_type* grid, size_t timeStep, std::vector<double>* waterFlux, std::vector<double>* oilFlux, std::vector<double>* gasFlux)
{
if (timeStep > timeStepCount())
{
return false;
}
openTimeStep(timeStep);
if (!m_ecl_files[timeStep])
{
return false;
}
ecl_file_view_type* summaryView = ecl_file_get_global_view(m_ecl_files[timeStep]);
ecl_nnc_geometry_type* nnc_geo = ecl_nnc_geometry_alloc(grid);
{
ecl_nnc_data_type* waterFluxData = ecl_nnc_data_alloc_wat_flux(grid, nnc_geo, summaryView);
const double* waterFluxValues = ecl_nnc_data_get_values(waterFluxData);
waterFlux->insert(waterFlux->end(), &waterFluxValues[0], &waterFluxValues[ecl_nnc_data_get_size(waterFluxData)]);
ecl_nnc_data_free(waterFluxData);
}
{
ecl_nnc_data_type* oilFluxData = ecl_nnc_data_alloc_oil_flux(grid, nnc_geo, summaryView);
const double* oilFluxValues = ecl_nnc_data_get_values(oilFluxData);
oilFlux->insert(oilFlux->end(), &oilFluxValues[0], &oilFluxValues[ecl_nnc_data_get_size(oilFluxData)]);
ecl_nnc_data_free(oilFluxData);
}
{
ecl_nnc_data_type* gasFluxData = ecl_nnc_data_alloc_gas_flux(grid, nnc_geo, summaryView);
const double* gasFluxValues = ecl_nnc_data_get_values(gasFluxData);
gasFlux->insert(gasFlux->end(), &gasFluxValues[0], &gasFluxValues[ecl_nnc_data_get_size(gasFluxData)]);
ecl_nnc_data_free(gasFluxData);
}
ecl_nnc_geometry_free(nnc_geo);
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/FileInterface/RifEclipseRestartFilesetAccess.h
View File

@ -49,6 +49,8 @@ public:
void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts);
bool results(const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values);
bool dynamicNNCResults(const ecl_grid_type* grid, size_t timeStep, std::vector<double>* waterFlux, std::vector<double>* oilFlux, std::vector<double>* gasFlux) override;
virtual void readWellData(well_info_type* well_info, bool importCompleteMswData);
virtual int readUnitsType();

44
ApplicationCode/FileInterface/RifEclipseUnifiedRestartFileAccess.cpp
View File

@ -23,6 +23,8 @@
#include "ert/ecl/ecl_file.h"
#include "ert/ecl/ecl_kw_magic.h"
#include "ert/ecl/ecl_nnc_geometry.h"
#include "ert/ecl/ecl_nnc_data.h"
#include <QDebug>
@ -150,6 +152,48 @@ bool RifEclipseUnifiedRestartFileAccess::results(const QString& resultName, size
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RifEclipseUnifiedRestartFileAccess::dynamicNNCResults(const ecl_grid_type* grid, size_t timeStep, std::vector<double>* waterFlux, std::vector<double>* oilFlux, std::vector<double>* gasFlux)
{
if (timeStep > timeStepCount())
{
return false;
}
if (!openFile())
{
return false;
}
ecl_file_view_type* summaryView = ecl_file_get_restart_view(m_ecl_file, timeStep, 0, 0, 0);
ecl_nnc_geometry_type* nnc_geo = ecl_nnc_geometry_alloc(grid);
{
ecl_nnc_data_type* waterFluxData = ecl_nnc_data_alloc_wat_flux(grid, nnc_geo, summaryView);
const double* waterFluxValues = ecl_nnc_data_get_values(waterFluxData);
waterFlux->insert(waterFlux->end(), &waterFluxValues[0], &waterFluxValues[ecl_nnc_data_get_size(waterFluxData)]);
ecl_nnc_data_free(waterFluxData);
}
{
ecl_nnc_data_type* oilFluxData = ecl_nnc_data_alloc_oil_flux(grid, nnc_geo, summaryView);
const double* oilFluxValues = ecl_nnc_data_get_values(oilFluxData);
oilFlux->insert(oilFlux->end(), &oilFluxValues[0], &oilFluxValues[ecl_nnc_data_get_size(oilFluxData)]);
ecl_nnc_data_free(oilFluxData);
}
{
ecl_nnc_data_type* gasFluxData = ecl_nnc_data_alloc_gas_flux(grid, nnc_geo, summaryView);
const double* gasFluxValues = ecl_nnc_data_get_values(gasFluxData);
gasFlux->insert(gasFlux->end(), &gasFluxValues[0], &gasFluxValues[ecl_nnc_data_get_size(gasFluxData)]);
ecl_nnc_data_free(gasFluxData);
}
ecl_nnc_geometry_free(nnc_geo);
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/FileInterface/RifEclipseUnifiedRestartFileAccess.h
View File

@ -52,6 +52,8 @@ public:
void resultNames(QStringList* resultNames, std::vector<size_t>* resultDataItemCounts);
bool results(const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values);
bool dynamicNNCResults(const ecl_grid_type* grid, size_t timeStep, std::vector<double>* waterFlux, std::vector<double>* oilFlux, std::vector<double>* gasFlux) override;
virtual void readWellData(well_info_type * well_info, bool importCompleteMswData);
virtual int readUnitsType();

28
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -419,7 +419,10 @@ bool RifReaderEclipseOutput::open(const QString& fileName, RigEclipseCaseData* e
{
progInfo.setProgressDescription("Reading NNC data");
progInfo.setNextProgressIncrement(5);
transferNNCData(mainEclGrid, m_ecl_init_file, eclipseCase->mainGrid());
transferStaticNNCData(mainEclGrid, m_ecl_init_file, eclipseCase->mainGrid());
progInfo.incrementProgress();
transferDynamicNNCData(mainEclGrid, eclipseCase->mainGrid());
progInfo.incrementProgress();
progInfo.setProgressDescription("Processing NNC data");
@ -574,7 +577,7 @@ void RifReaderEclipseOutput::importFaults(const QStringList& fileSet, cvf::Colle
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifReaderEclipseOutput::transferNNCData( const ecl_grid_type * mainEclGrid , ecl_file_type * init_file, RigMainGrid * mainGrid)
void RifReaderEclipseOutput::transferStaticNNCData(const ecl_grid_type* mainEclGrid , ecl_file_type* init_file, RigMainGrid* mainGrid)
{
if (!m_ecl_init_file ) return;
@ -593,7 +596,7 @@ void RifReaderEclipseOutput::transferNNCData( const ecl_grid_type * mainEclGrid
// Transform to our own data structures
mainGrid->nncData()->connections().resize(numNNC);
std::vector<double>& transmissibilityValues = mainGrid->nncData()->makeConnectionScalarResult(cvf::UNDEFINED_SIZE_T);
std::vector<double>& transmissibilityValues = mainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::COMB_TRANS);
const double* transValues = ecl_nnc_data_get_values(tran_data);
for (int nIdx = 0; nIdx < numNNC; ++nIdx)
@ -612,6 +615,25 @@ void RifReaderEclipseOutput::transferNNCData( const ecl_grid_type * mainEclGrid
ecl_nnc_data_free(tran_data);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RifReaderEclipseOutput::transferDynamicNNCData(const ecl_grid_type* mainEclGrid, RigMainGrid* mainGrid)
{
CVF_ASSERT(mainEclGrid && mainGrid);
size_t timeStepCount = m_dynamicResultsAccess->timeStepCount();
std::vector< std::vector<double> >& waterFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::FLUX_WAT, timeStepCount);
std::vector< std::vector<double> >& oilFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::FLUX_OIL, timeStepCount);
std::vector< std::vector<double> >& gasFluxData = mainGrid->nncData()->makeDynamicConnectionScalarResult(RigNNCData::FLUX_GAS, timeStepCount);
for (size_t timeStep = 0; timeStep < timeStepCount; ++timeStep)
{
m_dynamicResultsAccess->dynamicNNCResults(mainEclGrid, timeStep, &waterFluxData[timeStep], &oilFluxData[timeStep], &gasFluxData[timeStep]);
}
}
//--------------------------------------------------------------------------------------------------
///

4
ApplicationCode/FileInterface/RifReaderEclipseOutput.h
View File

@ -82,8 +82,8 @@ private:
bool openDynamicAccess();
void extractResultValuesBasedOnPorosityModel(PorosityModelResultType matrixOrFracture, std::vector<double>* values, const std::vector<double>& fileValues);
void transferNNCData( const ecl_grid_type * mainEclGrid , ecl_file_type * init_file,
RigMainGrid * mainGrid);
void transferStaticNNCData(const ecl_grid_type* mainEclGrid , ecl_file_type* init_file, RigMainGrid* mainGrid);
void transferDynamicNNCData(const ecl_grid_type* mainEclGrid, RigMainGrid* mainGrid);
RifEclipseRestartDataAccess* createDynamicResultsAccess();

11
ApplicationCode/ModelVisualization/RivFaultPartMgr.cpp
View File

@ -103,7 +103,7 @@ void RivFaultPartMgr::updateCellResultColor(size_t timeStepIndex, RimEclipseCell
{
CVF_ASSERT(cellResultColors);
updateNNCColors(cellResultColors);
updateNNCColors(timeStepIndex, cellResultColors);
RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(cellResultColors->porosityModel());
RimEclipseView* eclipseView = cellResultColors->reservoirView();
@ -182,7 +182,7 @@ void RivFaultPartMgr::updateCellResultColor(size_t timeStepIndex, RimEclipseCell
//--------------------------------------------------------------------------------------------------
void RivFaultPartMgr::updateCellEdgeResultColor(size_t timeStepIndex, RimEclipseCellColors* cellResultColors, RimCellEdgeColors* cellEdgeResultColors)
{
updateNNCColors(cellResultColors);
updateNNCColors(timeStepIndex, cellResultColors);
if (m_nativeFaultFaces.notNull())
{
@ -375,7 +375,7 @@ void RivFaultPartMgr::updatePartEffect()
m_oppositeFaultFaces->setEffect(geometryOnlyEffect.p());
}
updateNNCColors(NULL);
updateNNCColors(0, NULL);
// Update mesh colors as well, in case of change
RiaPreferences* prefs = RiaApplication::instance()->preferences();
@ -642,7 +642,7 @@ caf::FaceCulling RivFaultPartMgr::faceCullingMode() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivFaultPartMgr::updateNNCColors(RimEclipseCellColors* cellResultColors)
void RivFaultPartMgr::updateNNCColors(size_t timeStepIndex, RimEclipseCellColors* cellResultColors)
{
if (m_NNCFaces.isNull()) return;
@ -661,10 +661,11 @@ void RivFaultPartMgr::updateNNCColors(RimEclipseCellColors* cellResultColors)
if (showNncsWithScalarMappedColor)
{
size_t scalarSetIndex = cellResultColors->scalarResultIndex();
RimDefines::ResultCatType resultType = cellResultColors->resultType();
const cvf::ScalarMapper* mapper = cellResultColors->legendConfig()->scalarMapper();
m_NNCGenerator->textureCoordinates(m_NNCTextureCoords.p(), mapper, scalarSetIndex);
m_NNCGenerator->textureCoordinates(m_NNCTextureCoords.p(), mapper, resultType, scalarSetIndex, timeStepIndex);
cvf::ref<cvf::Effect> nncEffect;

2
ApplicationCode/ModelVisualization/RivFaultPartMgr.h
View File

@ -70,7 +70,7 @@ private:
void generatePartGeometry();
void updatePartEffect();
void updateNNCColors(RimEclipseCellColors* cellResultColors);
void updateNNCColors(size_t timeStepIndex, RimEclipseCellColors* cellResultColors);
caf::FaceCulling faceCullingMode() const;

18
ApplicationCode/ModelVisualization/RivNNCGeometryGenerator.cpp
View File

@ -145,14 +145,26 @@ void RivNNCGeometryGenerator::computeArrays()
/// Calculates the texture coordinates in a "nearly" one dimensional texture.
/// Undefined values are coded with a y-texture coordinate value of 1.0 instead of the normal 0.5
//--------------------------------------------------------------------------------------------------
void RivNNCGeometryGenerator::textureCoordinates(cvf::Vec2fArray* textureCoords, const cvf::ScalarMapper* mapper, size_t scalarResultIndex) const
void RivNNCGeometryGenerator::textureCoordinates(cvf::Vec2fArray* textureCoords,
const cvf::ScalarMapper* mapper,
RimDefines::ResultCatType resultType,
size_t scalarResultIndex,
size_t timeStepIndex) const
{
size_t numVertices = m_vertices->size();
textureCoords->resize(numVertices);
cvf::Vec2f* rawPtr = textureCoords->ptr();
const std::vector<double>* nncResultVals = m_nncData->connectionScalarResult(scalarResultIndex);
const std::vector<double>* nncResultVals;
if (resultType == RimDefines::STATIC_NATIVE)
{
nncResultVals = m_nncData->staticConnectionScalarResult(scalarResultIndex);
}
else if (resultType == RimDefines::DYNAMIC_NATIVE)
{
nncResultVals = m_nncData->dynamicConnectionScalarResult(scalarResultIndex, timeStepIndex);
}
if (!nncResultVals)
{
textureCoords->setAll(cvf::Vec2f(0.0f, 1.0f));

8
ApplicationCode/ModelVisualization/RivNNCGeometryGenerator.h
View File

@ -18,6 +18,9 @@
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RimDefines.h"
#include "cvfBase.h"
#include "cvfObject.h"
#include "cvfArray.h"
@ -45,7 +48,10 @@ public:
void setCellVisibility( const cvf::UByteArray* cellVisibilities, const RigGridBase * grid);
void textureCoordinates(cvf::Vec2fArray* textureCoords,
const cvf::ScalarMapper* mapper, size_t scalarResultIndex) const;
const cvf::ScalarMapper* mapper,
RimDefines::ResultCatType resultType,
size_t scalarResultIndex,
size_t timeStepIndex) const;
// Mapping between cells and geometry
cvf::ref<cvf::Array<size_t> > triangleToNNCIndex() const;

12
ApplicationCode/ProjectDataModel/RimDefines.cpp
View File

@ -97,6 +97,18 @@ bool RimDefines::isPerCellFaceResult(const QString& resultName)
{
return true;
}
else if (resultName.compare(RimDefines::combinedWaterFluxResultName(), Qt::CaseInsensitive) == 0)
{
return true;
}
else if (resultName.compare(RimDefines::combinedOilFluxResultName(), Qt::CaseInsensitive) == 0)
{
return true;
}
else if (resultName.compare(RimDefines::combinedGasFluxResultName(), Qt::CaseInsensitive) == 0)
{
return true;
}
return false;
}

3
ApplicationCode/ProjectDataModel/RimDefines.h
View File

@ -49,6 +49,9 @@ public:
static QString undefinedGridFaultName() { return "Undefined Grid Faults"; }
static QString undefinedGridFaultWithInactiveName() { return "Undefined Grid Faults With Inactive"; }
static QString combinedTransmissibilityResultName() { return "TRANXYZ"; }
static QString combinedWaterFluxResultName() { return "FLRWATIJK"; }
static QString combinedOilFluxResultName() { return "FLROILIJK"; }
static QString combinedGasFluxResultName() { return "FLRGASIJK"; }
static QString ternarySaturationResultName() { return "TERNARY"; }
static QString combinedMultResultName() { return "MULTXYZ"; }

17
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -582,7 +582,22 @@ bool RimEclipseCase::openReserviorCase()
size_t combinedTransResIdx = results->cellResults()->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedTransmissibilityResultName());
if (combinedTransResIdx != cvf::UNDEFINED_SIZE_T)
{
eclipseCaseData()->mainGrid()->nncData()->setCombTransmisibilityScalarResultIndex(combinedTransResIdx);
eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::COMB_TRANS, combinedTransResIdx);
}
size_t combinedWatFluxResIdx = results->cellResults()->findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedWaterFluxResultName());
if (combinedWatFluxResIdx != cvf::UNDEFINED_SIZE_T)
{
eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::FLUX_WAT, combinedWatFluxResIdx);
}
size_t combinedOilFluxResIdx = results->cellResults()->findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedOilFluxResultName());
if (combinedOilFluxResIdx != cvf::UNDEFINED_SIZE_T)
{
eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::FLUX_OIL, combinedOilFluxResIdx);
}
size_t combinedGasFluxResIdx = results->cellResults()->findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedGasFluxResultName());
if (combinedGasFluxResIdx != cvf::UNDEFINED_SIZE_T)
{
eclipseCaseData()->mainGrid()->nncData()->setScalarResultIndex(RigNNCData::FLUX_GAS, combinedGasFluxResIdx);
}
}

44
ApplicationCode/ProjectDataModel/RimReservoirCellResultsStorage.cpp
View File

@ -324,6 +324,27 @@ size_t RimReservoirCellResultsStorage::findOrLoadScalarResult(RimDefines::Result
computeRiTRANSbyAreaComponent(resultName);
}
}
else if (type == RimDefines::DYNAMIC_NATIVE)
{
if (resultName == RimDefines::combinedWaterFluxResultName())
{
this->findOrLoadScalarResult(type, "FLRWATI+");
this->findOrLoadScalarResult(type, "FLRWATJ+");
this->findOrLoadScalarResult(type, "FLRWATK+");
}
else if (resultName == RimDefines::combinedOilFluxResultName())
{
this->findOrLoadScalarResult(type, "FLROILI+");
this->findOrLoadScalarResult(type, "FLROILJ+");
this->findOrLoadScalarResult(type, "FLROILK+");
}
else if (resultName == RimDefines::combinedGasFluxResultName())
{
this->findOrLoadScalarResult(type, "FLRGASI+");
this->findOrLoadScalarResult(type, "FLRGASJ+");
this->findOrLoadScalarResult(type, "FLRGASK+");
}
}
if (isDataPresent(scalarResultIndex))
@ -966,7 +987,7 @@ void RimReservoirCellResultsStorage::computeNncCombRiTrans()
if (!m_cellResults) return;
size_t riCombTransScalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedRiTranResultName());
if (m_ownerMainGrid->nncData()->connectionScalarResult(riCombTransScalarResultIndex)) return;
if (m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombTransScalarResultIndex)) return;
double cdarchy = darchysValue();
@ -985,7 +1006,8 @@ void RimReservoirCellResultsStorage::computeNncCombRiTrans()
std::vector<double> & permXResults = m_cellResults->cellScalarResults(permXResultIdx)[0];
std::vector<double> & permYResults = m_cellResults->cellScalarResults(permYResultIdx)[0];
std::vector<double> & permZResults = m_cellResults->cellScalarResults(permZResultIdx)[0];
std::vector<double> & riCombTransResults = m_ownerMainGrid->nncData()->makeConnectionScalarResult(riCombTransScalarResultIndex);
std::vector<double> & riCombTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::RI_COMB_TRANS);
m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_TRANS, riCombTransScalarResultIndex);
std::vector<double> * ntgResults = NULL;
if (hasNTGResults)
@ -1226,11 +1248,14 @@ void RimReservoirCellResultsStorage::computeNncCombRiMULT()
size_t riCombTransScalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedRiTranResultName());
size_t combTransScalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedTransmissibilityResultName());
if (m_ownerMainGrid->nncData()->connectionScalarResult(riCombMultScalarResultIndex)) return;
if (m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombMultScalarResultIndex)) return;
std::vector<double> & riMultResults = m_ownerMainGrid->nncData()->makeConnectionScalarResult(riCombMultScalarResultIndex);
const std::vector<double> * riTransResults = m_ownerMainGrid->nncData()->connectionScalarResult(riCombTransScalarResultIndex);
const std::vector<double> * transResults = m_ownerMainGrid->nncData()->connectionScalarResult(combTransScalarResultIndex);
std::vector<double> & riMultResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::RI_COMB_MULT);
const std::vector<double> * riTransResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(RigNNCData::RI_COMB_TRANS);
const std::vector<double> * transResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(RigNNCData::COMB_TRANS);
m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_MULT, riCombMultScalarResultIndex);
m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_TRANS, riCombTransScalarResultIndex);
m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::COMB_TRANS, combTransScalarResultIndex);
for (size_t nncConIdx = 0; nncConIdx < riMultResults.size(); ++nncConIdx)
{
@ -1359,10 +1384,11 @@ void RimReservoirCellResultsStorage::computeNncCombRiTRANSbyArea()
size_t riCombTransByAreaScResIdx = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedRiAreaNormTranResultName());
size_t combTransScalarResultIndex = m_cellResults->findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::combinedTransmissibilityResultName());
if (m_ownerMainGrid->nncData()->connectionScalarResult(riCombTransByAreaScResIdx)) return;
if (m_ownerMainGrid->nncData()->staticConnectionScalarResult(riCombTransByAreaScResIdx)) return;
std::vector<double> & riAreaNormTransResults = m_ownerMainGrid->nncData()->makeConnectionScalarResult(riCombTransByAreaScResIdx);
const std::vector<double> * transResults = m_ownerMainGrid->nncData()->connectionScalarResult(combTransScalarResultIndex);
std::vector<double> & riAreaNormTransResults = m_ownerMainGrid->nncData()->makeStaticConnectionScalarResult(RigNNCData::RI_COMB_TRANS_BY_AREA);
m_ownerMainGrid->nncData()->setScalarResultIndex(RigNNCData::RI_COMB_TRANS_BY_AREA, riCombTransByAreaScResIdx);
const std::vector<double> * transResults = m_ownerMainGrid->nncData()->staticConnectionScalarResult(combTransScalarResultIndex);
const std::vector<RigConnection>& connections = m_ownerMainGrid->nncData()->connections();

52
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -321,6 +321,30 @@ size_t RigCaseCellResultsData::addEmptyScalarResult(RimDefines::ResultCatType ty
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::STATIC_NATIVE, RimDefines::riAreaNormTranZResultName()));
statisticsCalculator = calc;
}
else if (resultName == RimDefines::combinedWaterFluxResultName())
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRWATI+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRWATJ+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRWATK+"));
statisticsCalculator = calc;
}
else if (resultName == RimDefines::combinedOilFluxResultName())
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLROILI+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLROILJ+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLROILK+"));
statisticsCalculator = calc;
}
else if (resultName == RimDefines::combinedGasFluxResultName())
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRGASI+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRGASJ+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRGASK+"));
statisticsCalculator = calc;
}
else
{
statisticsCalculator = new RigEclipseNativeStatCalc(this, scalarResultIndex);
@ -694,6 +718,34 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
}
}
// FLUX
{
size_t waterIndex = findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedWaterFluxResultName());
if (waterIndex == cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRWATI+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRWATJ+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRWATK+") != cvf::UNDEFINED_SIZE_T)
{
addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedWaterFluxResultName(), false);
}
size_t oilIndex = findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedOilFluxResultName());
if (oilIndex == cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLROILI+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLROILJ+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLROILK+") != cvf::UNDEFINED_SIZE_T)
{
addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedOilFluxResultName(), false);
}
size_t gasIndex = findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedGasFluxResultName());
if (gasIndex == cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRGASI+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRGASJ+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RimDefines::DYNAMIC_NATIVE, "FLRGASK+") != cvf::UNDEFINED_SIZE_T)
{
addEmptyScalarResult(RimDefines::DYNAMIC_NATIVE, RimDefines::combinedGasFluxResultName(), false);
}
}
// TRANSXYZ
{
size_t tranX, tranY, tranZ;

96
ApplicationCode/ReservoirDataModel/RigNNCData.cpp
View File

@ -166,38 +166,92 @@ void RigNNCData::processConnections(const RigMainGrid& mainGrid)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double>& RigNNCData::makeConnectionScalarResult(size_t scalarResultIndex)
std::vector<double>& RigNNCData::makeStaticConnectionScalarResult(NNCDataType nncDataType)
{
std::vector<double>& results = m_connectionResults[scalarResultIndex];
results.resize(m_connections.size(), HUGE_VAL);
std::vector< std::vector<double> >& results = m_connectionResults[nncDataType];
results.resize(1);
results[0].resize(m_connections.size(), HUGE_VAL);
return results[0];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>* RigNNCData::staticConnectionScalarResult(size_t scalarResultIndex) const
{
const NNCDataType* nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (!nncDataType) return nullptr;
std::map<NNCDataType, std::vector< std::vector<double> > >::const_iterator it = m_connectionResults.find(*nncDataType);
CVF_ASSERT(it->second.size() == 1);
if (it != m_connectionResults.end())
{
return &(it->second[0]);
}
else
{
return nullptr;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector< std::vector<double> >& RigNNCData::makeDynamicConnectionScalarResult(NNCDataType nncDataType, size_t timeStepCount)
{
auto& results = m_connectionResults[nncDataType];
results.resize(timeStepCount);
return results;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>* RigNNCData::connectionScalarResult(size_t scalarResultIndex) const
const std::vector< std::vector<double> >* RigNNCData::dynamicConnectionScalarResult(size_t scalarResultIndex) const
{
std::map<size_t, std::vector<double> >::const_iterator it = m_connectionResults.find(scalarResultIndex);
const NNCDataType* nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (!nncDataType) return nullptr;
auto it = m_connectionResults.find(*nncDataType);
if (it != m_connectionResults.end())
{
return &(it->second);
}
else
return NULL;
{
return nullptr;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigNNCData::setCombTransmisibilityScalarResultIndex(size_t scalarResultIndex)
const std::vector<double>* RigNNCData::dynamicConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const
{
std::map<size_t, std::vector<double> >::iterator it = m_connectionResults.find(cvf::UNDEFINED_SIZE_T);
const NNCDataType* nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (!nncDataType) return nullptr;
auto it = m_connectionResults.find(*nncDataType);
if (it != m_connectionResults.end())
{
std::vector<double>& emptyData = m_connectionResults[scalarResultIndex];
std::vector<double>& realData = m_connectionResults[cvf::UNDEFINED_SIZE_T];
emptyData.swap(realData);
m_connectionResults.erase(cvf::UNDEFINED_SIZE_T);
if (it->second.size() > timeStep)
{
return &(it->second[timeStep]);
}
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigNNCData::setScalarResultIndex(NNCDataType nncDataType, size_t scalarResultIndex)
{
m_resultIndexToNNCDataType[scalarResultIndex] = nncDataType;
}
//--------------------------------------------------------------------------------------------------
@ -205,10 +259,26 @@ void RigNNCData::setCombTransmisibilityScalarResultIndex(size_t scalarResultInde
//--------------------------------------------------------------------------------------------------
bool RigNNCData::hasScalarValues(size_t scalarResultIndex)
{
std::map<size_t, std::vector<double> >::iterator it = m_connectionResults.find(scalarResultIndex);
const NNCDataType* nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (!nncDataType) return false;
auto it = m_connectionResults.find(*nncDataType);
return (it != m_connectionResults.end());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigNNCData::NNCDataType* RigNNCData::getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const
{
auto it = m_resultIndexToNNCDataType.find(scalarResultIndex);
if (it != m_resultIndexToNNCDataType.end())
{
return &it->second;
}
return nullptr;
}
/*
//--------------------------------------------------------------------------------------------------
/// TODO: Possibly not needed !

27
ApplicationCode/ReservoirDataModel/RigNNCData.h
View File

@ -57,8 +57,17 @@ public:
class RigNNCData : public cvf::Object
{
public:
enum NNCDataType {
FLUX_WAT,
FLUX_OIL,
FLUX_GAS,
COMB_TRANS,
RI_COMB_TRANS,
RI_COMB_MULT,
RI_COMB_TRANS_BY_AREA,
};
RigNNCData();
void processConnections(const RigMainGrid& mainGrid);
@ -66,10 +75,13 @@ public:
std::vector<RigConnection>& connections() { return m_connections; }
const std::vector<RigConnection>& connections() const { return m_connections; };
std::vector<double>& makeConnectionScalarResult(size_t scalarResultIndex);
const std::vector<double>* connectionScalarResult(size_t scalarResultIndex) const;
std::vector<double>& makeStaticConnectionScalarResult(NNCDataType nncDataType);
const std::vector<double>* staticConnectionScalarResult(size_t scalarResultIndex) const;
std::vector< std::vector<double> >& makeDynamicConnectionScalarResult(NNCDataType nncDataType, size_t timeStepCount);
const std::vector< std::vector<double> >* dynamicConnectionScalarResult(size_t scalarResultIndex) const;
const std::vector<double>* dynamicConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const;
void setCombTransmisibilityScalarResultIndex(size_t scalarResultIndex);
void setScalarResultIndex(NNCDataType nncDataType, size_t scalarResultIndex);
bool hasScalarValues(size_t scalarResultIndex);
@ -78,7 +90,10 @@ private: // This section is possibly not needed
//typedef std::map<size_t, caf::FixedArray<std::vector<size_t>, 7 > > ConnectionSearchMap;
//ConnectionSearchMap m_cellIdxToFaceToConnectionIdxMap;
const NNCDataType* getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const;
private:
std::vector<RigConnection> m_connections;
std::map<size_t, std::vector<double> > m_connectionResults; ///< scalarResultIndex to value array map
std::vector<RigConnection> m_connections;
std::map<NNCDataType, std::vector< std::vector<double> > > m_connectionResults;
std::map<size_t, NNCDataType> m_resultIndexToNNCDataType;
};

2
ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
View File

@ -542,7 +542,7 @@ void RigReservoirBuilderMock::addFaults(RigEclipseCaseData* eclipseCase)
addNnc(grid, i1, j1, k1, i2, j2, k2, nncConnections);
}
std::vector<double>& tranVals = grid->nncData()->makeConnectionScalarResult(cvf::UNDEFINED_SIZE_T);
std::vector<double>& tranVals = grid->nncData()->makeStaticConnectionScalarResult(RigNNCData::COMB_TRANS);
for (size_t cIdx = 0; cIdx < tranVals.size(); ++cIdx)
{
tranVals[cIdx] = 0.2;

36
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.cpp
View File

@ -125,6 +125,42 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromUiResultName(Rig
return cellFaceAccessObject;
}
else if (uiResultName == RimDefines::combinedWaterFluxResultName())
{
cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor(grid);
cvf::ref<RigResultAccessor> xRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "FLRWATI+");
cvf::ref<RigResultAccessor> yRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "FLRWATJ+");
cvf::ref<RigResultAccessor> zRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "FLRWATK+");
cellFaceAccessObject->setTransResultAccessors(xRiAreaNormTransAccessor.p(), yRiAreaNormTransAccessor.p(), zRiAreaNormTransAccessor.p());
return cellFaceAccessObject;
}
else if (uiResultName == RimDefines::combinedOilFluxResultName())
{
cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor(grid);
cvf::ref<RigResultAccessor> xRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "FLROILI+");
cvf::ref<RigResultAccessor> yRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "FLROILJ+");
cvf::ref<RigResultAccessor> zRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "FLROILK+");
cellFaceAccessObject->setTransResultAccessors(xRiAreaNormTransAccessor.p(), yRiAreaNormTransAccessor.p(), zRiAreaNormTransAccessor.p());
return cellFaceAccessObject;
}
else if (uiResultName == RimDefines::combinedGasFluxResultName())
{
cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor(grid);
cvf::ref<RigResultAccessor> xRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "FLRGASI+");
cvf::ref<RigResultAccessor> yRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "FLRGASJ+");
cvf::ref<RigResultAccessor> zRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "FLRGASK+");
cellFaceAccessObject->setTransResultAccessors(xRiAreaNormTransAccessor.p(), yRiAreaNormTransAccessor.p(), zRiAreaNormTransAccessor.p());
return cellFaceAccessObject;
}
return RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, uiResultName);
}

11
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

@ -348,7 +348,16 @@ QString RiuResultTextBuilder::nncResultText()
if (m_reservoirView->currentFaultResultColors())
{
size_t scalarResultIdx = m_reservoirView->currentFaultResultColors()->scalarResultIndex();
const std::vector<double>* nncValues = nncData->connectionScalarResult(scalarResultIdx);
RimDefines::ResultCatType resultType = m_reservoirView->currentFaultResultColors()->resultType();
const std::vector<double>* nncValues;
if (resultType == RimDefines::STATIC_NATIVE)
{
nncValues = nncData->staticConnectionScalarResult(scalarResultIdx);
}
else if (resultType == RimDefines::DYNAMIC_NATIVE)
{
nncValues = nncData->dynamicConnectionScalarResult(scalarResultIdx, m_timeStepIndex);
}
if (nncValues)
{
QString resultVar = m_reservoirView->currentFaultResultColors()->resultVariableUiName();