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 dev into pre-proto

Browse Source 
Conflicts:
	ApplicationCode/ProjectDataModel/RimEclipseView.cpp
	ApplicationCode/ProjectDataModel/RimEclipseView.h
This commit is contained in:
Magne Sjaastad
2017-01-10 10:09:44 +01:00
parent 95864e8ae8 8970d93a4d
commit 9cd17ec508
142 changed files with 1759 additions and 937 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
ApplicationCode/ReservoirDataModel/CMakeLists_files.cmake
View File

@@ -7,7 +7,7 @@ endif()
set (SOURCE_GROUP_HEADER_FILES
${CEE_CURRENT_LIST_DIR}RigActiveCellInfo.h
${CEE_CURRENT_LIST_DIR}RigCell.h
${CEE_CURRENT_LIST_DIR}RigCaseData.h
${CEE_CURRENT_LIST_DIR}RigEclipseCaseData.h
${CEE_CURRENT_LIST_DIR}RigGridBase.h
${CEE_CURRENT_LIST_DIR}RigGridManager.h
${CEE_CURRENT_LIST_DIR}RigResultAccessor.h
@@ -56,7 +56,7 @@ ${CEE_CURRENT_LIST_DIR}RigTesselatorTools.h
set (SOURCE_GROUP_SOURCE_FILES
${CEE_CURRENT_LIST_DIR}RigActiveCellInfo.cpp
${CEE_CURRENT_LIST_DIR}RigCell.cpp
${CEE_CURRENT_LIST_DIR}RigCaseData.cpp
${CEE_CURRENT_LIST_DIR}RigEclipseCaseData.cpp
${CEE_CURRENT_LIST_DIR}RigGridBase.cpp
${CEE_CURRENT_LIST_DIR}RigGridManager.cpp
${CEE_CURRENT_LIST_DIR}RigResultAccessor.cpp
@@ -68,6 +68,7 @@ ${CEE_CURRENT_LIST_DIR}RigCombTransResultAccessor.cpp
${CEE_CURRENT_LIST_DIR}RigCombMultResultAccessor.cpp
${CEE_CURRENT_LIST_DIR}RigResultModifierFactory.cpp
${CEE_CURRENT_LIST_DIR}RigFormationNames.cpp
${CEE_CURRENT_LIST_DIR}RigFlowDiagResultAddress.cpp
${CEE_CURRENT_LIST_DIR}RigFlowDiagResults.cpp
${CEE_CURRENT_LIST_DIR}RigFlowDiagResultFrames.cpp
${CEE_CURRENT_LIST_DIR}RigFlowDiagSolverInterface.cpp

2
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.h
View File

@@ -23,7 +23,6 @@
#include "RifReaderInterface.h"
#include "RimDefines.h"
#include "RigStatisticsDataCache.h"
#include <QDateTime>
@@ -33,6 +32,7 @@
class RifReaderInterface;
class RigMainGrid;
class RigActiveCellInfo;
class RigStatisticsDataCache;
//==================================================================================================
/// Class containing the results for the complete number of active cells. Both main grid and LGR's

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

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

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

@@ -20,19 +20,31 @@
#pragma once
#include <vector>
#include "RigCell.h"
#include "cvfVector3.h"
#include "RifReaderInterface.h"
#include "cvfAssert.h"
#include "cvfObject.h"
#include "RigMainGrid.h"
#include "RigSingleWellResultsData.h"
#include "RigActiveCellInfo.h"
#include "cvfVector3.h"
#include "cvfStructGrid.h"
#include <vector>
class RigCaseCellResultsData;
class RigFormationNames;
class RigMainGrid;
class RigGridBase;
class RigCaseCellResultsData;
class RigActiveCellInfo;
class RigSingleWellResultsData;
class RigCell;
class RigCaseData : public cvf::Object
struct RigWellResultPoint;
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RigEclipseCaseData : public cvf::Object
{
public:
enum UnitsType
@@ -43,11 +55,11 @@ public:
};
public:
RigCaseData();
~RigCaseData();
RigEclipseCaseData();
~RigEclipseCaseData();
RigMainGrid* mainGrid() { return m_mainGrid.p(); }
const RigMainGrid* mainGrid() const { return m_mainGrid.p(); }
RigMainGrid* mainGrid();
const RigMainGrid* mainGrid() const;
void setMainGrid(RigMainGrid* mainGrid);
void allGrids(std::vector<RigGridBase*>* grids); // To be removed
@@ -84,6 +96,7 @@ private:
void computeActiveCellIJKBBox();
void computeWellCellsPrGrid();
void computeActiveCellsGeometryBoundingBox();
private:
cvf::ref<RigMainGrid> m_mainGrid;
@@ -100,5 +113,4 @@ private:
cvf::Collection<cvf::UIntArray> m_gridCellToResultWellIndex; //< Array pr grid with index to well pr cell telling which well a cell is in
UnitsType m_unitsType;
};

4
ApplicationCode/ReservoirDataModel/RigEclipseWellLogExtractor.cpp
View File

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

8
ApplicationCode/ReservoirDataModel/RigEclipseWellLogExtractor.h
View File

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

47
ApplicationCode/ReservoirDataModel/RigFlowDiagResultAddress.cpp Normal file
View File

@@ -0,0 +1,47 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2017- Statoil ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RigFlowDiagResultAddress.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigFlowDiagResultAddress::isNativeResult() const
{
return (((variableName == RIG_FLD_TOF_RESNAME) || (variableName == RIG_FLD_CELL_FRACTION_RESNAME)) && selectedTracerNames.size() <= 1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::string RigFlowDiagResultAddress::uiText()
{
std::string uiVarname = variableName;
std::string uitext = uiVarname;
uitext += " (";
for (const std::string& tracerName : selectedTracerNames)
{
uitext += " " + tracerName;
}
uitext += " )";
return uitext;
}

3
ApplicationCode/ReservoirDataModel/RigFlowDiagResultAddress.h
View File

@@ -38,8 +38,9 @@ public:
selectedTracerNames.insert(tracerName);
}
bool isNativeResult() const { return ( ( (variableName == RIG_FLD_TOF_RESNAME) || (variableName == RIG_FLD_CELL_FRACTION_RESNAME) ) && selectedTracerNames.size() <= 1); }
bool isNativeResult() const;
std::string uiText();
std::string variableName;
std::set<std::string> selectedTracerNames;

338
ApplicationCode/ReservoirDataModel/RigFlowDiagResults.cpp
View File

@@ -17,13 +17,16 @@
/////////////////////////////////////////////////////////////////////////////////
#include "RigFlowDiagResults.h"
#include "RigActiveCellInfo.h"
#include "RigEclipseCaseData.h"
#include "RigFlowDiagSolverInterface.h"
#include "RimFlowDiagSolution.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseCase.h"
#include "RigCaseData.h"
#include "RigFlowDiagStatCalc.h"
#include "RimEclipseCase.h"
#include "RimEclipseResultCase.h"
#include "RimFlowDiagSolution.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -160,164 +163,209 @@ std::vector<double>* RigFlowDiagResults::calculateDerivedResult(const RigFlowDia
{
if (resVarAddr.isNativeResult()) return nullptr;
size_t activeCellCount = this->activeCellInfo(resVarAddr)->reservoirActiveCellCount();
if (resVarAddr.variableName == RIG_FLD_TOF_RESNAME)
{
std::vector<const std::vector<double>* > injectorTOFs = findResultsForSelectedTracers(resVarAddr, frameIndex,
RIG_FLD_TOF_RESNAME, RimFlowDiagSolution::INJECTOR);
std::vector<const std::vector<double>* > injectorFractions = findResultsForSelectedTracers(resVarAddr, frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME, RimFlowDiagSolution::INJECTOR);
std::vector<const std::vector<double>* > producerTOFs = findResultsForSelectedTracers(resVarAddr, frameIndex,
RIG_FLD_TOF_RESNAME, RimFlowDiagSolution::PRODUCER);
std::vector<const std::vector<double>* > producerFractions = findResultsForSelectedTracers(resVarAddr, frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME, RimFlowDiagSolution::PRODUCER);
std::vector<double> injectorTotalFractions;
std::vector<double> injectorFractMultTof;
calculateSumOfFractionAndFractionMultTOF(activeCellCount, injectorFractions, injectorTOFs, &injectorTotalFractions, &injectorFractMultTof);
std::vector<double> producerTotalFractions;
std::vector<double> producerFractMultTof;
calculateSumOfFractionAndFractionMultTOF(activeCellCount, producerFractions, producerTOFs, &producerTotalFractions, &producerFractMultTof);
RigFlowDiagResultFrames* averageTofFrames = this->createScalarResult(resVarAddr);
std::vector<double>& averageTof = averageTofFrames->frameData(frameIndex);
averageTof.resize(activeCellCount, HUGE_VAL);
for (size_t acIdx = 0 ; acIdx < activeCellCount; ++acIdx)
{
if ( injectorTotalFractions[acIdx] == 0.0 && producerTotalFractions[acIdx] == 0.0 )
{
averageTof[acIdx] = HUGE_VAL;
}
else
{
double retVal = 0.0;
if (injectorTotalFractions[acIdx] != 0.0) retVal += (1.0/injectorTotalFractions[acIdx]) * injectorFractMultTof[acIdx];
if (producerTotalFractions[acIdx] != 0.0) retVal += (1.0/producerTotalFractions[acIdx]) * producerFractMultTof[acIdx];
averageTof[acIdx] = retVal;
}
}
return &averageTof;
return calculateAverageTOFResult(resVarAddr, frameIndex);
}
else if (resVarAddr.variableName == RIG_FLD_CELL_FRACTION_RESNAME)
{
std::vector<const std::vector<double>* > fractions = findResultsForSelectedTracers(resVarAddr,
frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME,
RimFlowDiagSolution::UNDEFINED);
RigFlowDiagResultFrames* sumOfFractionsFrames = this->createScalarResult(resVarAddr);
std::vector<double>& sumOfFractions = sumOfFractionsFrames->frameData(frameIndex);
calculateSumOfFractions(fractions, activeCellCount, &sumOfFractions);
return &sumOfFractions;
return calculateSumOfFractionsResult(resVarAddr, frameIndex);
}
else if ( resVarAddr.variableName == RIG_FLD_COMMUNICATION_RESNAME )
{
std::vector<const std::vector<double>* > injectorFractions = findResultsForSelectedTracers(resVarAddr,
frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME,
RimFlowDiagSolution::INJECTOR);
std::vector<const std::vector<double>* > producerFractions = findResultsForSelectedTracers(resVarAddr,
frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME,
RimFlowDiagSolution::PRODUCER);
std::vector<double> sumOfInjectorFractions;
calculateSumOfFractions(injectorFractions, activeCellCount, &sumOfInjectorFractions);
std::vector<double> sumOfProducerFractions;
calculateSumOfFractions(producerFractions, activeCellCount, &sumOfProducerFractions);
RigFlowDiagResultFrames* commFrames = this->createScalarResult(resVarAddr);
std::vector<double>& commPI = commFrames->frameData(frameIndex);
commPI.resize(activeCellCount, HUGE_VAL);
for ( size_t acIdx = 0 ; acIdx < activeCellCount; ++acIdx )
{
if ( (sumOfInjectorFractions)[acIdx] == HUGE_VAL ) continue;
if ( (sumOfProducerFractions)[acIdx] == HUGE_VAL ) continue;
(commPI)[acIdx] = (sumOfInjectorFractions)[acIdx] * (sumOfProducerFractions)[acIdx];
}
return &commPI;
return calculateCommunicationResult(resVarAddr, frameIndex);
}
else if ( resVarAddr.variableName == RIG_FLD_MAX_FRACTION_TRACER_RESNAME )
{
std::vector<int> selectedTracerIdxToGlobalTracerIdx;
{
selectedTracerIdxToGlobalTracerIdx.resize(resVarAddr.selectedTracerNames.size(), -1);
std::vector<QString> allTracerNames = m_flowDiagSolution->tracerNames();
int selTracerIdx = 0;
for ( const std::string& tracerName: resVarAddr.selectedTracerNames )
{
for ( int globIdx = 0; globIdx < allTracerNames.size(); ++globIdx )
{
if ( allTracerNames[globIdx].toStdString() == tracerName )
{
selectedTracerIdxToGlobalTracerIdx[selTracerIdx] = globIdx;
break;
}
}
++selTracerIdx;
}
}
RigFlowDiagResultFrames* maxFractionTracerIdxFrames = this->createScalarResult(resVarAddr);
std::vector<double>& maxFractionTracerIdx = maxFractionTracerIdxFrames->frameData(frameIndex);
{
std::vector<const std::vector<double>* > fractions = findResultsForSelectedTracers(resVarAddr,
frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME,
RimFlowDiagSolution::UNDEFINED);
maxFractionTracerIdx.resize(activeCellCount, HUGE_VAL);
std::vector<double> maxFraction;
maxFraction.resize(activeCellCount, -HUGE_VAL);
for ( size_t frIdx = 0; frIdx < fractions.size(); ++frIdx )
{
const std::vector<double> * fr = fractions[frIdx];
for ( size_t acIdx = 0 ; acIdx < activeCellCount; ++acIdx )
{
if ( (*fr)[acIdx] == HUGE_VAL) continue;
if ( maxFraction[acIdx] < (*fr)[acIdx] )
{
maxFraction[acIdx] = (*fr)[acIdx];
maxFractionTracerIdx[acIdx] = frIdx;
}
}
}
}
for ( size_t acIdx = 0 ; acIdx < activeCellCount; ++acIdx )
{
if (maxFractionTracerIdx[acIdx] == HUGE_VAL) continue;
double selectedTracerIdx = static_cast<int>( maxFractionTracerIdx[acIdx]);
maxFractionTracerIdx[acIdx] = selectedTracerIdxToGlobalTracerIdx[selectedTracerIdx];
}
return &maxFractionTracerIdx;
return calculateTracerWithMaxFractionResult(resVarAddr, frameIndex);
}
return nullptr;
}
std::vector<const std::vector<double>* > RigFlowDiagResults::findResultsForSelectedTracers(const RigFlowDiagResultAddress& resVarAddr,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double>* RigFlowDiagResults::calculateAverageTOFResult(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex)
{
std::vector<const std::vector<double>* > injectorTOFs = findResultsForSelectedTracers(resVarAddr, frameIndex,
RIG_FLD_TOF_RESNAME, RimFlowDiagSolution::INJECTOR);
std::vector<const std::vector<double>* > injectorFractions = findResultsForSelectedTracers(resVarAddr, frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME, RimFlowDiagSolution::INJECTOR);
std::vector<const std::vector<double>* > producerTOFs = findResultsForSelectedTracers(resVarAddr, frameIndex,
RIG_FLD_TOF_RESNAME, RimFlowDiagSolution::PRODUCER);
std::vector<const std::vector<double>* > producerFractions = findResultsForSelectedTracers(resVarAddr, frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME, RimFlowDiagSolution::PRODUCER);
size_t activeCellCount = this->activeCellInfo(resVarAddr)->reservoirActiveCellCount();
std::vector<double> injectorTotalFractions;
std::vector<double> injectorFractMultTof;
calculateSumOfFractionAndFractionMultTOF(activeCellCount, injectorFractions, injectorTOFs, &injectorTotalFractions, &injectorFractMultTof);
std::vector<double> producerTotalFractions;
std::vector<double> producerFractMultTof;
calculateSumOfFractionAndFractionMultTOF(activeCellCount, producerFractions, producerTOFs, &producerTotalFractions, &producerFractMultTof);
RigFlowDiagResultFrames* averageTofFrames = this->createScalarResult(resVarAddr);
std::vector<double>& averageTof = averageTofFrames->frameData(frameIndex);
averageTof.resize(activeCellCount, HUGE_VAL);
for ( size_t acIdx = 0 ; acIdx < activeCellCount; ++acIdx )
{
if ( injectorTotalFractions[acIdx] == 0.0 && producerTotalFractions[acIdx] == 0.0 )
{
averageTof[acIdx] = HUGE_VAL;
}
else
{
double retVal = 0.0;
if ( injectorTotalFractions[acIdx] != 0.0 ) retVal += (1.0/injectorTotalFractions[acIdx]) * injectorFractMultTof[acIdx];
if ( producerTotalFractions[acIdx] != 0.0 ) retVal += (1.0/producerTotalFractions[acIdx]) * producerFractMultTof[acIdx];
averageTof[acIdx] = retVal;
}
}
/// Test to remove all averaging
// if (injectorTOFs.size()) averageTof = (*injectorTOFs[0]);
return &averageTof;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double>* RigFlowDiagResults::calculateSumOfFractionsResult(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex)
{
std::vector<const std::vector<double>* > fractions = findResultsForSelectedTracers(resVarAddr,
frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME,
RimFlowDiagSolution::UNDEFINED);
RigFlowDiagResultFrames* sumOfFractionsFrames = this->createScalarResult(resVarAddr);
std::vector<double>& sumOfFractions = sumOfFractionsFrames->frameData(frameIndex);
size_t activeCellCount = this->activeCellInfo(resVarAddr)->reservoirActiveCellCount();
calculateSumOfFractions(fractions, activeCellCount, &sumOfFractions);
return &sumOfFractions;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double>* RigFlowDiagResults::calculateTracerWithMaxFractionResult(const RigFlowDiagResultAddress &resVarAddr, size_t frameIndex)
{
std::vector<int> selectedTracerIdxToGlobalTracerIdx;
{
selectedTracerIdxToGlobalTracerIdx.resize(resVarAddr.selectedTracerNames.size(), -1);
std::vector<QString> allTracerNames = m_flowDiagSolution->tracerNames();
int selTracerIdx = 0;
for ( const std::string& tracerName: resVarAddr.selectedTracerNames )
{
for ( size_t globIdx = 0; globIdx < allTracerNames.size(); ++globIdx )
{
if ( allTracerNames[globIdx].toStdString() == tracerName )
{
selectedTracerIdxToGlobalTracerIdx[selTracerIdx] = static_cast<int>(globIdx);
break;
}
}
++selTracerIdx;
}
}
size_t activeCellCount = this->activeCellInfo(resVarAddr)->reservoirActiveCellCount();
RigFlowDiagResultFrames* maxFractionTracerIdxFrames = this->createScalarResult(resVarAddr);
std::vector<double>& maxFractionTracerIdx = maxFractionTracerIdxFrames->frameData(frameIndex);
{
std::vector<const std::vector<double>* > fractions = findResultsForSelectedTracers(resVarAddr,
frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME,
RimFlowDiagSolution::UNDEFINED);
maxFractionTracerIdx.resize(activeCellCount, HUGE_VAL);
std::vector<double> maxFraction;
maxFraction.resize(activeCellCount, -HUGE_VAL);
for ( size_t frIdx = 0; frIdx < fractions.size(); ++frIdx )
{
const std::vector<double> * fr = fractions[frIdx];
for ( size_t acIdx = 0 ; acIdx < activeCellCount; ++acIdx )
{
if ( (*fr)[acIdx] == HUGE_VAL ) continue;
if ( maxFraction[acIdx] < (*fr)[acIdx] )
{
maxFraction[acIdx] = (*fr)[acIdx];
maxFractionTracerIdx[acIdx] = frIdx;
}
}
}
}
for ( size_t acIdx = 0 ; acIdx < activeCellCount; ++acIdx )
{
if ( maxFractionTracerIdx[acIdx] == HUGE_VAL ) continue;
double selectedTracerIdx = static_cast<int>(maxFractionTracerIdx[acIdx]);
maxFractionTracerIdx[acIdx] = selectedTracerIdxToGlobalTracerIdx[selectedTracerIdx];
}
return &maxFractionTracerIdx;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double>* RigFlowDiagResults::calculateCommunicationResult(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex)
{
std::vector<const std::vector<double>* > injectorFractions = findResultsForSelectedTracers(resVarAddr,
frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME,
RimFlowDiagSolution::INJECTOR);
std::vector<const std::vector<double>* > producerFractions = findResultsForSelectedTracers(resVarAddr,
frameIndex,
RIG_FLD_CELL_FRACTION_RESNAME,
RimFlowDiagSolution::PRODUCER);
size_t activeCellCount = this->activeCellInfo(resVarAddr)->reservoirActiveCellCount();
std::vector<double> sumOfInjectorFractions;
calculateSumOfFractions(injectorFractions, activeCellCount, &sumOfInjectorFractions);
std::vector<double> sumOfProducerFractions;
calculateSumOfFractions(producerFractions, activeCellCount, &sumOfProducerFractions);
RigFlowDiagResultFrames* commFrames = this->createScalarResult(resVarAddr);
std::vector<double>& commPI = commFrames->frameData(frameIndex);
commPI.resize(activeCellCount, HUGE_VAL);
for ( size_t acIdx = 0 ; acIdx < activeCellCount; ++acIdx )
{
if ( (sumOfInjectorFractions)[acIdx] == HUGE_VAL ) continue;
if ( (sumOfProducerFractions)[acIdx] == HUGE_VAL ) continue;
(commPI)[acIdx] = (sumOfInjectorFractions)[acIdx] * (sumOfProducerFractions)[acIdx];
}
return &commPI;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<const std::vector<double>* > RigFlowDiagResults::findResultsForSelectedTracers(const RigFlowDiagResultAddress& resVarAddr,
size_t frameIndex,
const std::string& nativeResultName,
RimFlowDiagSolution::TracerStatusType wantedTracerType)

8
ApplicationCode/ReservoirDataModel/RigFlowDiagResults.h
View File

@@ -64,6 +64,14 @@ private:
std::vector<double>* calculateDerivedResult(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex);
std::vector<double>* calculateAverageTOFResult(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex);
std::vector<double>* calculateSumOfFractionsResult(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex);
std::vector<double>* calculateTracerWithMaxFractionResult(const RigFlowDiagResultAddress &resVarAddr, size_t frameIndex);
std::vector<double>* calculateCommunicationResult(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex);
std::vector<const std::vector<double>* > findResultsForSelectedTracers(const RigFlowDiagResultAddress& resVarAddr,
size_t frameIndex,
const std::string& nativeResultName,

217
ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp
View File

@@ -17,15 +17,19 @@
/////////////////////////////////////////////////////////////////////////////////
#include "RigFlowDiagSolverInterface.h"
#include "RimFlowDiagSolution.h"
#include "RimEclipseResultCase.h"
#include "RigCaseCellResultsData.h"
#include "RigFlowDiagInterfaceTools.h"
#include "RifEclipseOutputFileTools.h"
#include "RigCaseData.h"
#include "RimEclipseCase.h"
#include "RifReaderInterface.h"
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h"
#include "RigFlowDiagInterfaceTools.h"
#include "RimEclipseCase.h"
#include "RimEclipseResultCase.h"
#include "RimFlowDiagSolution.h"
#include <QMessageBox>
//--------------------------------------------------------------------------------------------------
@@ -38,45 +42,30 @@ RigFlowDiagTimeStepResult::RigFlowDiagTimeStepResult(size_t activeCellCount)
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFlowDiagTimeStepResult::setInjectorTracerTOF(const std::string& tracerName, const std::map<int, double>& cellValues)
{
std::set<std::string> tracers;
tracers.insert(tracerName);
this->addResult(RigFlowDiagResultAddress(RIG_FLD_TOF_RESNAME, tracers), cellValues);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFlowDiagTimeStepResult::setInjectorTracerFraction(const std::string& tracerName, const std::map<int, double>& cellValues)
void RigFlowDiagTimeStepResult::setTracerTOF(const std::string& tracerName, const std::map<int, double>& cellValues)
{
std::set<std::string> tracers;
tracers.insert(tracerName);
RigFlowDiagResultAddress resAddr(RIG_FLD_TOF_RESNAME, tracers);
this->addResult(RigFlowDiagResultAddress(RIG_FLD_CELL_FRACTION_RESNAME, tracers), cellValues);
this->addResult(resAddr, cellValues);
std::vector<double>& activeCellValues = m_nativeResults[resAddr];
for (double & val: activeCellValues)
{
val = val * 1.15741e-5; // days pr second. Converting to days
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFlowDiagTimeStepResult::setProducerTracerTOF(const std::string& tracerName, const std::map<int, double>& cellValues)
{
std::set<std::string> tracers;
tracers.insert(tracerName);
this->addResult(RigFlowDiagResultAddress(RIG_FLD_TOF_RESNAME, tracers), cellValues);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFlowDiagTimeStepResult::setProducerTracerFraction(const std::string& tracerName, const std::map<int, double>& cellValues)
void RigFlowDiagTimeStepResult::setTracerFraction(const std::string& tracerName, const std::map<int, double>& cellValues)
{
std::set<std::string> tracers;
tracers.insert(tracerName);
@@ -98,13 +87,26 @@ void RigFlowDiagTimeStepResult::addResult(const RigFlowDiagResultAddress& resAdd
}
}
class RigOpmFldStaticData : public cvf::Object
{
public:
RigOpmFldStaticData(const std::string& grid, const std::string& init) : eclGraph(Opm::ECLGraph::load(grid, init)), m_hasUnifiedRestartFile(false) {}
Opm::ECLGraph eclGraph;
std::unique_ptr<Opm::FlowDiagnostics::Toolbox> fldToolbox;
bool m_hasUnifiedRestartFile;
QStringList restartFileNames;
};
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigFlowDiagSolverInterface::RigFlowDiagSolverInterface(RimEclipseResultCase * eclipseCase)
: m_eclipseCase(eclipseCase)
{
}
//--------------------------------------------------------------------------------------------------
@@ -115,6 +117,7 @@ RigFlowDiagSolverInterface::~RigFlowDiagSolverInterface()
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -126,86 +129,122 @@ RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate(size_t timeStepI
RigFlowDiagTimeStepResult result(m_eclipseCase->reservoirData()->activeCellInfo(RifReaderInterface::MATRIX_RESULTS)->reservoirActiveCellCount());
// Get set of files
QString gridFileName = m_eclipseCase->gridFileName();
QStringList m_filesWithSameBaseName;
if ( !RifEclipseOutputFileTools::findSiblingFilesWithSameBaseName(gridFileName, &m_filesWithSameBaseName) ) return result;
QString initFileName = RifEclipseOutputFileTools::firstFileNameOfType(m_filesWithSameBaseName, ECL_INIT_FILE);
Opm::ECLGraph graph = Opm::ECLGraph::load(gridFileName.toStdString(),
initFileName.toStdString());
// Look for unified restart file
QString restartFileName = RifEclipseOutputFileTools::firstFileNameOfType(m_filesWithSameBaseName, ECL_UNIFIED_RESTART_FILE);
if ( restartFileName.isEmpty() )
if ( m_opmFldData.isNull() )
{
// Look for set of restart files (one file per time step)
// Get set of files
QString gridFileName = m_eclipseCase->gridFileName();
QStringList restartFileNames;
restartFileNames = RifEclipseOutputFileTools::filterFileNamesOfType(m_filesWithSameBaseName, ECL_RESTART_FILE);
QStringList m_filesWithSameBaseName;
size_t restartFileCount = static_cast<size_t>(restartFileNames.size());
size_t maxTimeStepCount = m_eclipseCase->reservoirData()->results(RifReaderInterface::MATRIX_RESULTS)->maxTimeStepCount();
if ( !RifEclipseOutputFileTools::findSiblingFilesWithSameBaseName(gridFileName, &m_filesWithSameBaseName) ) return result;
if (restartFileCount <= timeStepIndex && restartFileCount != maxTimeStepCount )
QString initFileName = RifEclipseOutputFileTools::firstFileNameOfType(m_filesWithSameBaseName, ECL_INIT_FILE);
m_opmFldData = new RigOpmFldStaticData(gridFileName.toStdString(),
initFileName.toStdString());
const Opm::FlowDiagnostics::ConnectivityGraph connGraph =
Opm::FlowDiagnostics::ConnectivityGraph{ static_cast<int>(m_opmFldData->eclGraph.numCells()),
m_opmFldData->eclGraph.neighbours() };
// Create the Toolbox.
m_opmFldData->fldToolbox.reset(new Opm::FlowDiagnostics::Toolbox{ connGraph });
m_opmFldData->fldToolbox->assignPoreVolume( m_opmFldData->eclGraph.poreVolume());
// Look for unified restart file
QString restartFileName = RifEclipseOutputFileTools::firstFileNameOfType(m_filesWithSameBaseName, ECL_UNIFIED_RESTART_FILE);
if ( !restartFileName.isEmpty() )
{
QMessageBox::critical(nullptr, "ResInsight", "Flow Diagnostics: Could not find all the restart files. Results will not be loaded.");
return result;
m_opmFldData->eclGraph.assignFluxDataSource(restartFileName.toStdString());
m_opmFldData->m_hasUnifiedRestartFile = true;
}
else
{
restartFileNames.sort(); // To make sure they are sorted in increasing *.X000N order. Hack. Should probably be actual time stored on file.
restartFileName = restartFileNames[static_cast<int>(timeStepIndex)];
m_opmFldData->restartFileNames = RifEclipseOutputFileTools::filterFileNamesOfType(m_filesWithSameBaseName, ECL_RESTART_FILE);
size_t restartFileCount = static_cast<size_t>(m_opmFldData->restartFileNames.size());
size_t maxTimeStepCount = m_eclipseCase->reservoirData()->results(RifReaderInterface::MATRIX_RESULTS)->maxTimeStepCount();
if (restartFileCount <= timeStepIndex && restartFileCount != maxTimeStepCount )
{
QMessageBox::critical(nullptr, "ResInsight", "Flow Diagnostics: Could not find all the restart files. Results will not be loaded.");
return result;
}
m_opmFldData->restartFileNames.sort(); // To make sure they are sorted in increasing *.X000N order. Hack. Should probably be actual time stored on file.
m_opmFldData->m_hasUnifiedRestartFile = false;
}
}
graph.assignFluxDataSource(restartFileName.toStdString());
if ( ! graph.selectReportStep(static_cast<int>(timeStepIndex)) )
if ( ! m_opmFldData->m_hasUnifiedRestartFile )
{
QString restartFileName = m_opmFldData->restartFileNames[static_cast<int>(timeStepIndex)];
m_opmFldData->eclGraph.assignFluxDataSource(restartFileName.toStdString());
}
if ( ! m_opmFldData->eclGraph.selectReportStep(static_cast<int>(timeStepIndex)) )
{
QMessageBox::critical(nullptr, "ResInsight", "Flow Diagnostics: Could not find the requested timestep in the result file. Results will not be loaded.");
return result;
}
// Set up flow Toolbox with timestep data
{
Toolbox fdTool = RigFlowDiagInterfaceTools::initialiseFlowDiagnostics(graph);
Opm::FlowDiagnostics::ConnectionValues connectionsVals = RigFlowDiagInterfaceTools::Hack::convert_flux_to_SI( RigFlowDiagInterfaceTools::extractFluxField(m_opmFldData->eclGraph));
m_opmFldData->fldToolbox->assignConnectionFlux(connectionsVals);
Opm::ECLWellSolution wsol = Opm::ECLWellSolution{};
const std::vector<Opm::ECLWellSolution::WellData> well_fluxes =
wsol.solution(m_opmFldData->eclGraph.rawResultData(), m_opmFldData->eclGraph.numGrids());
m_opmFldData->fldToolbox->assignInflowFlux(RigFlowDiagInterfaceTools::extractWellFlows(m_opmFldData->eclGraph, well_fluxes));
}
// Injection Solution
{
std::vector<CellSet> injectorCellSet;
for ( const auto& tIt: injectorTracers )
{
std::vector<CellSet> injectorCellSet;
for ( const auto& tIt: injectorTracers )
{
injectorCellSet.push_back(CellSet(CellSetID(tIt.first), tIt.second));
}
Solution injSol = fdTool.computeInjectionDiagnostics(injectorCellSet).fd;
for ( const CellSetID& tracerId: injSol.startPoints() )
{
CellSetValues tofVals = injSol.timeOfFlight(tracerId);
result.setInjectorTracerTOF(tracerId.to_string(), tofVals);
CellSetValues fracVals = injSol.concentration(tracerId);
result.setInjectorTracerFraction(tracerId.to_string(), fracVals);
}
injectorCellSet.push_back(CellSet(CellSetID(tIt.first), tIt.second));
}
Solution injSol = m_opmFldData->fldToolbox->computeInjectionDiagnostics(injectorCellSet).fd;
for ( const CellSetID& tracerId: injSol.startPoints() )
{
std::vector<CellSet> prodjCellSet;
for ( const auto& tIt: producerTracers )
{
prodjCellSet.push_back(CellSet(CellSetID(tIt.first), tIt.second));
}
Solution prodSol = fdTool.computeProductionDiagnostics(prodjCellSet).fd;
for ( const CellSetID& tracerId: prodSol.startPoints() )
{
CellSetValues tofVals = prodSol.timeOfFlight(tracerId);
result.setProducerTracerTOF(tracerId.to_string(), tofVals);
CellSetValues fracVals = prodSol.concentration(tracerId);
result.setInjectorTracerFraction(tracerId.to_string(), fracVals);
}
CellSetValues tofVals = injSol.timeOfFlight(tracerId);
result.setTracerTOF(tracerId.to_string(), tofVals);
CellSetValues fracVals = injSol.concentration(tracerId);
result.setTracerFraction(tracerId.to_string(), fracVals);
}
}
// Producer Solution
{
std::vector<CellSet> prodjCellSet;
for ( const auto& tIt: producerTracers )
{
prodjCellSet.push_back(CellSet(CellSetID(tIt.first), tIt.second));
}
Solution prodSol = m_opmFldData->fldToolbox->computeProductionDiagnostics(prodjCellSet).fd;
for ( const CellSetID& tracerId: prodSol.startPoints() )
{
CellSetValues tofVals = prodSol.timeOfFlight(tracerId);
result.setTracerTOF(tracerId.to_string(), tofVals);
CellSetValues fracVals = prodSol.concentration(tracerId);
result.setTracerFraction(tracerId.to_string(), fracVals);
}
}
return result; // Relying on implicit move constructor
}

11
ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.h
View File

@@ -35,10 +35,8 @@ class RigFlowDiagTimeStepResult
public:
RigFlowDiagTimeStepResult(size_t activeCellCount);
void setInjectorTracerTOF (const std::string& tracerName, const std::map<int, double>& cellValues);
void setInjectorTracerFraction(const std::string& tracerName, const std::map<int, double>& cellValues);
void setProducerTracerTOF (const std::string& tracerName, const std::map<int, double>& cellValues);
void setProducerTracerFraction(const std::string& tracerName, const std::map<int, double>& cellValues);
void setTracerTOF (const std::string& tracerName, const std::map<int, double>& cellValues);
void setTracerFraction(const std::string& tracerName, const std::map<int, double>& cellValues);
// Use to "steal" the data from this one using swap
std::map<RigFlowDiagResultAddress, std::vector<double> >& nativeResults() { return m_nativeResults; }
@@ -51,7 +49,8 @@ private:
};
class RigCaseData;
class RigEclipseCaseData;
class RigOpmFldStaticData;
class RigFlowDiagSolverInterface : public cvf::Object
{
@@ -66,6 +65,8 @@ public:
private:
RimEclipseResultCase * m_eclipseCase;
cvf::ref<RigOpmFldStaticData> m_opmFldData;
};

8
ApplicationCode/ReservoirDataModel/RigGridManager.cpp
View File

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

10
ApplicationCode/ReservoirDataModel/RigGridManager.h
View File

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

26
ApplicationCode/ReservoirDataModel/RigLasFileExporter.cpp
View File

@@ -24,6 +24,7 @@
#include "RimWellLogCurve.h"
#include "RimWellLogExtractionCurve.h"
#include "cafUtils.h"
#include "cvfAssert.h"
#include "laswell.hpp"
@@ -146,41 +147,34 @@ public:
std::string generateFilename() const
{
QString f;
QString fileBasenameCandidate;
QString separator("-");
if (!m_wellName.isEmpty())
{
f += m_wellName;
fileBasenameCandidate += m_wellName;
}
if (!m_caseName.isEmpty())
{
if (!f.isEmpty()) f += separator;
f += m_caseName;
if (!fileBasenameCandidate.isEmpty()) fileBasenameCandidate += separator;
fileBasenameCandidate += m_caseName;
}
// Add property name if only one curve is exported
if (m_logCurveData.size() == 1)
{
if (!f.isEmpty()) f += separator;
f += QString::fromStdString(m_logCurveData[0].channelName());
if (!fileBasenameCandidate.isEmpty()) fileBasenameCandidate += separator;
fileBasenameCandidate += QString::fromStdString(m_logCurveData[0].channelName());
}
if (!m_date.isEmpty())
{
if (!f.isEmpty()) f += separator;
f += m_date;
if (!fileBasenameCandidate.isEmpty()) fileBasenameCandidate += separator;
fileBasenameCandidate += m_date;
}
QString cleanFileName = f.trimmed();
cleanFileName.replace(".", "_");
cleanFileName.replace(",", "_");
cleanFileName.replace(":", "_");
cleanFileName.replace(";", "_");
cleanFileName.replace(" ", "_");
cleanFileName.replace("/", "_");
cleanFileName.replace(QRegExp("_+"), "_");
QString cleanFileName = caf::Utils::makeValidFileBasename( fileBasenameCandidate);
cleanFileName += ".las";

19
ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.cpp
View File

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

22
ApplicationCode/ReservoirDataModel/RigReservoirBuilderMock.h
View File

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

12
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.cpp
View File

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

10
ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.h
View File

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

6
ApplicationCode/ReservoirDataModel/RigResultModifierFactory.cpp
View File

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

6
ApplicationCode/ReservoirDataModel/RigResultModifierFactory.h
View File

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

10
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp
View File

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

10
ApplicationCode/ReservoirDataModel/RigTimeHistoryResultAccessor.cpp
View File

@@ -19,18 +19,18 @@
#include "RigTimeHistoryResultAccessor.h"
#include <cmath> // Needed for HUGE_VAL on Linux
#include "RigCaseData.h"
#include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h"
#include "RigGridBase.h"
#include "RigResultAccessor.h"
#include "RigResultAccessorFactory.h"
#include "RigCaseCellResultsData.h"
#include <cmath> // Needed for HUGE_VAL on Linux
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigTimeHistoryResultAccessor::RigTimeHistoryResultAccessor(RigCaseData* eclipseCaseData, size_t gridIndex, size_t cellIndex, size_t scalarResultIndex, RifReaderInterface::PorosityModelResultType porosityModel)
RigTimeHistoryResultAccessor::RigTimeHistoryResultAccessor(RigEclipseCaseData* eclipseCaseData, size_t gridIndex, size_t cellIndex, size_t scalarResultIndex, RifReaderInterface::PorosityModelResultType porosityModel)
: m_eclipseCaseData(eclipseCaseData),
m_gridIndex(gridIndex),
m_cellIndex(cellIndex),

6
ApplicationCode/ReservoirDataModel/RigTimeHistoryResultAccessor.h
View File

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