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

Merge remote-tracking branch 'origin/hdf-prototype' into dev

Browse Source
This commit is contained in:
Magne Sjaastad
2017-08-17 07:30:01 +02:00
parent 9d36517b1d 2febb1ea0b
commit a961221c2c
632 changed files with 9748 additions and 3722 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@@ -231,6 +231,11 @@ size_t RigCaseCellResultsData::findScalarResultIndex(const QString& resultName)
scalarResultIndex = this->findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, resultName);
}
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = this->findScalarResultIndex(RiaDefines::SOURSIMRL, resultName);
}
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T)
{
scalarResultIndex = this->findScalarResultIndex(RiaDefines::GENERATED, resultName);
@@ -323,6 +328,39 @@ size_t RigCaseCellResultsData::addEmptyScalarResult(RiaDefines::ResultCatType ty
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::STATIC_NATIVE, RiaDefines::riAreaNormTranZResultName()));
statisticsCalculator = calc;
}
else if (resultName == RiaDefines::combinedWaterFluxResultName())
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRWATI+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRWATJ+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRWATK+"));
statisticsCalculator = calc;
}
else if (resultName == RiaDefines::combinedOilFluxResultName())
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLROILI+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLROILJ+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLROILK+"));
statisticsCalculator = calc;
}
else if (resultName == RiaDefines::combinedGasFluxResultName())
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRGASI+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRGASJ+"));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRGASK+"));
statisticsCalculator = calc;
}
else if (resultName.endsWith("IJK"))
{
cvf::ref<RigEclipseMultiPropertyStatCalc> calc = new RigEclipseMultiPropertyStatCalc();
QString baseName = resultName.left(resultName.size() - 3);
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::GENERATED, QString("%1I").arg(baseName)));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::GENERATED, QString("%1J").arg(baseName)));
calc->addNativeStatisticsCalculator(this, findScalarResultIndex(RiaDefines::GENERATED, QString("%1K").arg(baseName)));
statisticsCalculator = calc;
}
else
{
statisticsCalculator = new RigEclipseNativeStatCalc(this, scalarResultIndex);
@@ -648,6 +686,23 @@ void RigCaseCellResultsData::setMustBeCalculated(size_t scalarResultIndex)
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::eraseAllSourSimData()
{
std::vector<size_t> sourSimIndices;
for (size_t i = 0; i < m_resultInfos.size(); i++)
{
RigEclipseResultInfo& ri = m_resultInfos[i];
if (ri.m_resultType == RiaDefines::SOURSIMRL)
{
ri.m_resultType = RiaDefines::REMOVED;
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -678,6 +733,34 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
}
}
// FLUX
{
size_t waterIndex = findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedWaterFluxResultName());
if (waterIndex == cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRWATI+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRWATJ+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRWATK+") != cvf::UNDEFINED_SIZE_T)
{
addEmptyScalarResult(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedWaterFluxResultName(), false);
}
size_t oilIndex = findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedOilFluxResultName());
if (oilIndex == cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLROILI+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLROILJ+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLROILK+") != cvf::UNDEFINED_SIZE_T)
{
addEmptyScalarResult(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedOilFluxResultName(), false);
}
size_t gasIndex = findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedGasFluxResultName());
if (gasIndex == cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRGASI+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRGASJ+") != cvf::UNDEFINED_SIZE_T &&
findScalarResultIndex(RiaDefines::DYNAMIC_NATIVE, "FLRGASK+") != cvf::UNDEFINED_SIZE_T)
{
addEmptyScalarResult(RiaDefines::DYNAMIC_NATIVE, RiaDefines::combinedGasFluxResultName(), false);
}
}
// TRANSXYZ
{
size_t tranX, tranY, tranZ;

1
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.h
View File

@@ -113,6 +113,7 @@ public:
bool mustBeCalculated(size_t scalarResultIndex) const;
void setMustBeCalculated(size_t scalarResultIndex);
void eraseAllSourSimData();
public:

340
ApplicationCode/ReservoirDataModel/RigNNCData.cpp
View File

@@ -166,38 +166,313 @@ void RigNNCData::processConnections(const RigMainGrid& mainGrid)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double>& RigNNCData::makeConnectionScalarResult(size_t scalarResultIndex)
std::vector<double>& RigNNCData::makeStaticConnectionScalarResult(QString 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
{
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (nncDataType.isNull()) return nullptr;
std::map<QString, std::vector< std::vector<double> > >::const_iterator it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
CVF_ASSERT(it->second.size() == 1);
return &(it->second[0]);
}
else
{
return nullptr;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>* RigNNCData::staticConnectionScalarResultByName(const QString& nncDataType) const
{
std::map<QString, std::vector< std::vector<double> > >::const_iterator it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
CVF_ASSERT(it->second.size() == 1);
return &(it->second[0]);
}
else
{
return nullptr;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector< std::vector<double> >& RigNNCData::makeDynamicConnectionScalarResult(QString 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);
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (nncDataType.isNull()) 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);
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (nncDataType.isNull()) 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;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<std::vector<double>>* RigNNCData::dynamicConnectionScalarResultByName(const QString& nncDataType) const
{
auto it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
return &(it->second);
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>* RigNNCData::dynamicConnectionScalarResultByName(const QString& nncDataType, size_t timeStep) const
{
auto it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
if (it->second.size() > timeStep)
{
return &(it->second[timeStep]);
}
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector< std::vector<double> >& RigNNCData::makeGeneratedConnectionScalarResult(QString nncDataType, size_t timeStepCount)
{
auto& results = m_connectionResults[nncDataType];
results.resize(timeStepCount);
return results;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector< std::vector<double> >* RigNNCData::generatedConnectionScalarResult(size_t scalarResultIndex) const
{
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (nncDataType.isNull()) return nullptr;
auto it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
return &(it->second);
}
else
{
return nullptr;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>* RigNNCData::generatedConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const
{
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (nncDataType.isNull()) return nullptr;
auto it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
if (it->second.size() > timeStep)
{
return &(it->second[timeStep]);
}
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector< std::vector<double> >* RigNNCData::generatedConnectionScalarResult(size_t scalarResultIndex)
{
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (nncDataType.isNull()) return nullptr;
auto it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
return &(it->second);
}
else
{
return nullptr;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double>* RigNNCData::generatedConnectionScalarResult(size_t scalarResultIndex, size_t timeStep)
{
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (nncDataType.isNull()) return nullptr;
auto it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
if (it->second.size() > timeStep)
{
return &(it->second[timeStep]);
}
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<std::vector<double>>* RigNNCData::generatedConnectionScalarResultByName(const QString& nncDataType) const
{
auto it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
return &(it->second);
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>* RigNNCData::generatedConnectionScalarResultByName(const QString& nncDataType, size_t timeStep) const
{
auto it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
if (it->second.size() > timeStep)
{
return &(it->second[timeStep]);
}
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::vector<double>>* RigNNCData::generatedConnectionScalarResultByName(const QString& nncDataType)
{
auto it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
return &(it->second);
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double>* RigNNCData::generatedConnectionScalarResultByName(const QString& nncDataType, size_t timeStep)
{
auto it = m_connectionResults.find(nncDataType);
if (it != m_connectionResults.end())
{
if (it->second.size() > timeStep)
{
return &(it->second[timeStep]);
}
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<QString> RigNNCData::availableProperties(NNCResultType resultType) const
{
std::vector<QString> properties;
for (auto it : m_connectionResults)
{
if (resultType == NNC_STATIC && it.second.size() == 1 && it.second[0].size() > 0 && isNative(it.first))
{
properties.push_back(it.first);
}
else if (resultType == NNC_DYNAMIC && it.second.size() > 1 && it.second[0].size() > 0 && isNative(it.first))
{
properties.push_back(it.first);
}
else if (resultType == NNC_GENERATED && !isNative(it.first))
{
properties.push_back(it.first);
}
}
return properties;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigNNCData::setScalarResultIndex(const QString& nncDataType, size_t scalarResultIndex)
{
m_resultIndexToNNCDataType[scalarResultIndex] = nncDataType;
}
//--------------------------------------------------------------------------------------------------
@@ -205,25 +480,40 @@ 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);
QString nncDataType = getNNCDataTypeFromScalarResultIndex(scalarResultIndex);
if (nncDataType.isNull()) return false;
auto it = m_connectionResults.find(nncDataType);
return (it != m_connectionResults.end());
}
/*
//--------------------------------------------------------------------------------------------------
/// TODO: Possibly not needed !
///
//--------------------------------------------------------------------------------------------------
const std::vector<size_t>& RigNNCData::findConnectionIndices( size_t reservoirCellIndex, cvf::StructGridInterface::FaceType face) const
const QString RigNNCData::getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const
{
ConnectionSearchMap::const_iterator it;
static std::vector<size_t> empty;
it = m_cellIdxToFaceToConnectionIdxMap.find(reservoirCellIndex);
if (it != m_cellIdxToFaceToConnectionIdxMap.end())
auto it = m_resultIndexToNNCDataType.find(scalarResultIndex);
if (it != m_resultIndexToNNCDataType.end())
{
return it->second[face];
return it->second;
}
return empty;
return QString();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigNNCData::isNative(QString nncDataType) const
{
if (nncDataType == RigNNCData::propertyNameCombTrans() ||
nncDataType == RigNNCData::propertyNameFluxGas() ||
nncDataType == RigNNCData::propertyNameFluxOil() ||
nncDataType == RigNNCData::propertyNameFluxWat() ||
nncDataType == RigNNCData::propertyNameRiCombMult() ||
nncDataType == RigNNCData::propertyNameRiCombTrans() ||
nncDataType == RigNNCData::propertyNameRiCombTransByArea())
{
return true;
}
return false;
}
*/

55
ApplicationCode/ReservoirDataModel/RigNNCData.h
View File

@@ -57,28 +57,61 @@ public:
class RigNNCData : public cvf::Object
{
public:
enum NNCResultType
{
NNC_DYNAMIC,
NNC_STATIC,
NNC_GENERATED
};
static QString propertyNameFluxWat() { return "FLRWAT"; }
static QString propertyNameFluxOil() { return "FLROIL"; }
static QString propertyNameFluxGas() { return "FLRGAS"; }
static QString propertyNameCombTrans() { return "TRAN"; }
static QString propertyNameRiCombTrans() { return "riTRAN"; }
static QString propertyNameRiCombTransByArea() { return "riTRANbyArea"; }
static QString propertyNameRiCombMult() { return "riMULT"; }
RigNNCData();
void processConnections(const RigMainGrid& mainGrid);
std::vector<RigConnection>& connections() { return m_connections; }
const std::vector<RigConnection>& connections() const { 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(QString nncDataType);
const std::vector<double>* staticConnectionScalarResult(size_t scalarResultIndex) const;
const std::vector<double>* staticConnectionScalarResultByName(const QString& nncDataType) const;
void setCombTransmisibilityScalarResultIndex(size_t scalarResultIndex);
std::vector< std::vector<double> >& makeDynamicConnectionScalarResult(QString 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;
const std::vector< std::vector<double> >* dynamicConnectionScalarResultByName(const QString& nncDataType) const;
const std::vector<double>* dynamicConnectionScalarResultByName(const QString& nncDataType, size_t timeStep) const;
std::vector< std::vector<double> >& makeGeneratedConnectionScalarResult(QString nncDataType, size_t timeStepCount);
const std::vector< std::vector<double> >* generatedConnectionScalarResult(size_t scalarResultIndex) const;
const std::vector<double>* generatedConnectionScalarResult(size_t scalarResultIndex, size_t timeStep) const;
std::vector< std::vector<double> >* generatedConnectionScalarResult(size_t scalarResultIndex);
std::vector<double>* generatedConnectionScalarResult(size_t scalarResultIndex, size_t timeStep);
const std::vector< std::vector<double> >* generatedConnectionScalarResultByName(const QString& nncDataType) const;
const std::vector<double>* generatedConnectionScalarResultByName(const QString& nncDataType, size_t timeStep) const;
std::vector< std::vector<double> >* generatedConnectionScalarResultByName(const QString& nncDataType);
std::vector<double>* generatedConnectionScalarResultByName(const QString& nncDataType, size_t timeStep);
std::vector<QString> availableProperties(NNCResultType resultType) const;
void setScalarResultIndex(const QString& nncDataType, size_t scalarResultIndex);
bool hasScalarValues(size_t scalarResultIndex);
private: // This section is possibly not needed
//const std::vector<size_t>& findConnectionIndices(size_t reservoirCellIndex, cvf::StructGridInterface::FaceType face) const;
//typedef std::map<size_t, caf::FixedArray<std::vector<size_t>, 7 > > ConnectionSearchMap;
//ConnectionSearchMap m_cellIdxToFaceToConnectionIdxMap;
private:
const QString getNNCDataTypeFromScalarResultIndex(size_t scalarResultIndex) const;
bool isNative(QString nncDataType) 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<QString, std::vector< std::vector<double> > > m_connectionResults;
std::map<size_t, QString> 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::propertyNameCombTrans());
for (size_t cIdx = 0; cIdx < tranVals.size(); ++cIdx)
{
tranVals[cIdx] = 0.2;

49
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.cpp
View File

@@ -125,6 +125,55 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromUiResultName(Rig
return cellFaceAccessObject;
}
else if (uiResultName == RiaDefines::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 == RiaDefines::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 == RiaDefines::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;
}
else if (uiResultName.endsWith("IJK"))
{
cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor(grid);
QString baseName = uiResultName.left(uiResultName.size() - 3);
cvf::ref<RigResultAccessor> iAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, QString("%1I").arg(baseName));
cvf::ref<RigResultAccessor> jAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, QString("%1J").arg(baseName));
cvf::ref<RigResultAccessor> kAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, QString("%1K").arg(baseName));
cellFaceAccessObject->setTransResultAccessors(iAccessor.p(), jAccessor.p(), kAccessor.p());
return cellFaceAccessObject;
}
return RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, uiResultName);
}

6
ApplicationCode/ReservoirDataModel/RigTimeHistoryResultAccessor.cpp
View File

@@ -29,7 +29,11 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RigTimeHistoryResultAccessor::timeHistoryValues(RigEclipseCaseData* eclipseCaseData, RimEclipseResultDefinition* resultDefinition, size_t gridIndex, size_t cellIndex, size_t timeStepCount)
std::vector<double> RigTimeHistoryResultAccessor::timeHistoryValues(RigEclipseCaseData* eclipseCaseData,
RimEclipseResultDefinition* resultDefinition,
size_t gridIndex,
size_t cellIndex,
size_t timeStepCount)
{
std::vector<double> values;