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

#4048 #4050 3D calculations : Add UI and calculation of case difference

Browse Source
This commit is contained in:
Magne Sjaastad
2019-02-12 12:48:18 +01:00
parent 93eca21b69
commit 1d4ab1a0b2
7 changed files with 333 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
ApplicationCode/ReservoirDataModel/CMakeLists_files.cmake
View File

@@ -67,6 +67,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RigWellPathGeometryTools.h
${CMAKE_CURRENT_LIST_DIR}/RigCaseRealizationParameters.h
${CMAKE_CURRENT_LIST_DIR}/RigGeoMechBoreHoleStressCalculator.h
${CMAKE_CURRENT_LIST_DIR}/RigPolyLinesData.h
${CMAKE_CURRENT_LIST_DIR}/RigCaseCellResultCalculator.h
)
@@ -132,7 +133,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RigWellPathGeometryTools.cpp
${CMAKE_CURRENT_LIST_DIR}/RigCaseRealizationParameters.cpp
${CMAKE_CURRENT_LIST_DIR}/RigGeoMechBoreHoleStressCalculator.cpp
${CMAKE_CURRENT_LIST_DIR}/RigPolyLinesData.cpp
${CMAKE_CURRENT_LIST_DIR}/RigCaseCellResultCalculator.cpp
)
list(APPEND CODE_HEADER_FILES

162
ApplicationCode/ReservoirDataModel/RigCaseCellResultCalculator.cpp Normal file
View File

@@ -0,0 +1,162 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2019- Equinor 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 "RigCaseCellResultCalculator.h"
#include "RiaApplication.h"
#include "RiaLogging.h"
#include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h"
#include "RigEclipseResultAddress.h"
#include "RigGridManager.h"
#include "RigMainGrid.h"
#include "RigResultAccessorFactory.h"
#include "RigResultModifier.h"
#include "RigResultModifierFactory.h"
#include "RimEclipseCase.h"
#include "RimProject.h"
#include "cvfAssert.h"
#include <algorithm>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigCaseCellResultCalculator::computeDifference(RigEclipseCaseData* sourceCase,
RiaDefines::PorosityModelType porosityModel,
const RigEclipseResultAddress& address)
{
CVF_ASSERT(address.isValid());
CVF_ASSERT(address.hasDifferenceCase());
// Assume at this stage that data for the case is available
// It is up to the caller to make sure the case is read from file
RigEclipseCaseData* otherCase = nullptr;
{
auto eclipseCases = RiaApplication::instance()->project()->eclipseCases();
for (RimEclipseCase* c : eclipseCases)
{
if (c->caseId() == address.m_differenceCaseId)
{
if (c && c->eclipseCaseData())
{
otherCase = c->eclipseCaseData();
}
}
}
}
if (!otherCase || !sourceCase)
{
RiaLogging::error("Missing input case for difference calculator");
return false;
}
RigMainGrid* sourceMainGrid = sourceCase->mainGrid();
RigMainGrid* otherMainGrid = otherCase->mainGrid();
if (!RigGridManager::isEqual(sourceMainGrid, otherMainGrid))
{
RiaLogging::error("Case difference : Grid cases do not match");
return false;
}
RigCaseCellResultsData* otherCaseResults = otherCase->results(porosityModel);
RigCaseCellResultsData* sourceCaseResults = sourceCase->results(porosityModel);
if (!otherCaseResults || !sourceCaseResults)
{
RiaLogging::error("Missing result data for difference calculator");
return false;
}
RigEclipseResultAddress nativeAddress(address);
nativeAddress.m_differenceCaseId = RigEclipseResultAddress::NO_CASE_DIFF;
if (!sourceCaseResults->ensureKnownResultLoaded(nativeAddress))
{
RiaLogging::error("Failed to load destination diff result");
return false;
}
if (!otherCaseResults->ensureKnownResultLoaded(nativeAddress))
{
RiaLogging::error("Failed to load difference result");
return false;
}
// Initialize difference result with infinity for correct number of time steps and values per time step
{
const std::vector<std::vector<double>>& srcFrames = sourceCaseResults->cellScalarResults(nativeAddress);
std::vector<std::vector<double>>& diffResultFrames = sourceCaseResults->modifiableCellScalarResultTimesteps(address);
diffResultFrames.resize(srcFrames.size());
for (size_t fIdx = 0; fIdx < srcFrames.size(); ++fIdx)
{
const std::vector<double>& srcVals = srcFrames[fIdx];
std::vector<double>& dstVals = diffResultFrames[fIdx];
dstVals.resize(srcVals.size(), std::numeric_limits<double>::infinity());
}
}
size_t otherFrameCount = otherCaseResults->cellScalarResults(nativeAddress).size();
size_t sourceFrameCount = sourceCaseResults->cellScalarResults(nativeAddress).size();
size_t maxFrameCount = std::min(otherFrameCount, sourceFrameCount);
for (size_t gridIdx = 0; gridIdx < sourceMainGrid->gridCount(); ++gridIdx)
{
auto grid = sourceMainGrid->gridByIndex(gridIdx);
const RigActiveCellInfo* activeCellInfo = sourceCaseResults->activeCellInfo();
for (size_t fIdx = 0; fIdx < maxFrameCount; ++fIdx)
{
cvf::ref<RigResultAccessor> sourceResultAccessor =
RigResultAccessorFactory::createFromResultAddress(sourceCase, gridIdx, porosityModel, fIdx, nativeAddress);
cvf::ref<RigResultAccessor> otherResultAccessor =
RigResultAccessorFactory::createFromResultAddress(otherCase, gridIdx, porosityModel, fIdx, nativeAddress);
cvf::ref<RigResultModifier> resultModifier =
RigResultModifierFactory::createResultModifier(sourceCase, gridIdx, porosityModel, fIdx, address);
for (size_t localGridCellIdx = 0; localGridCellIdx < grid->cellCount(); localGridCellIdx++)
{
size_t reservoirCellIndex = grid->reservoirCellIndex(localGridCellIdx);
if (activeCellInfo->isActive(reservoirCellIndex))
{
double sourceVal = sourceResultAccessor->cellScalar(localGridCellIdx);
double otherVal = otherResultAccessor->cellScalar(localGridCellIdx);
double difference = otherVal - sourceVal;
resultModifier->setCellScalar(localGridCellIdx, difference);
}
}
}
}
return true;
}

35
ApplicationCode/ReservoirDataModel/RigCaseCellResultCalculator.h Normal file
View File

@@ -0,0 +1,35 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2019- Equinor 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.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RiaPorosityModel.h"
class RigEclipseCaseData;
class RigEclipseResultAddress;
//==================================================================================================
///
//==================================================================================================
class RigCaseCellResultCalculator
{
public:
static bool computeDifference(RigEclipseCaseData* destination,
RiaDefines::PorosityModelType porosityModel,
const RigEclipseResultAddress& address);
};

16
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@@ -23,10 +23,12 @@
#include "RiaApplication.h"
#include "RiaLogging.h"
#include "RigCaseCellResultCalculator.h"
#include "RigEclipseCaseData.h"
#include "RigEclipseMultiPropertyStatCalc.h"
#include "RigEclipseNativeStatCalc.h"
#include "RigEclipseResultInfo.h"
#include "RigFormationNames.h"
#include "RigMainGrid.h"
#include "RigStatisticsDataCache.h"
#include "RigStatisticsMath.h"
@@ -44,7 +46,6 @@
#include <algorithm>
#include <cmath>
#include "RigFormationNames.h"
//--------------------------------------------------------------------------------------------------
///
@@ -404,7 +405,9 @@ QStringList RigCaseCellResultsData::resultNames(RiaDefines::ResultCatType resTyp
std::vector<RigEclipseResultInfo>::const_iterator it;
for (it = m_resultInfos.begin(); it != m_resultInfos.end(); ++it)
{
if (it->resultType() == resType && !it->eclipseResultAddress().isTimeLapse())
if (it->resultType() == resType &&
!it->eclipseResultAddress().isTimeLapse() &&
!it->eclipseResultAddress().hasDifferenceCase())
{
varList.push_back(it->resultName());
}
@@ -1122,6 +1125,15 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult(const RigEclipseResul
return scalarResultIndex;
}
else if (resVarAddr.hasDifferenceCase())
{
if (!RigCaseCellResultCalculator::computeDifference(this->m_ownerCaseData, RiaDefines::MATRIX_MODEL, resVarAddr))
{
return cvf::UNDEFINED_SIZE_T;
}
return scalarResultIndex;
}
// Load dependency data sets

21
ApplicationCode/ReservoirDataModel/RigEclipseResultAddress.h
View File

@@ -18,6 +18,7 @@
#pragma once
#include "RiaDefines.h"
#include <QString>
class RigEclipseResultAddress
@@ -26,20 +27,24 @@ public:
RigEclipseResultAddress()
: m_resultCatType(RiaDefines::UNDEFINED)
, m_timeLapseBaseFrameIdx(NO_TIME_LAPSE)
, m_differenceCaseId(NO_CASE_DIFF)
{}
explicit RigEclipseResultAddress(const QString& resultName)
: m_resultCatType(RiaDefines::UNDEFINED)
, m_resultName(resultName)
, m_timeLapseBaseFrameIdx(NO_TIME_LAPSE)
, m_differenceCaseId(NO_CASE_DIFF)
{}
explicit RigEclipseResultAddress(RiaDefines::ResultCatType type, const QString& resultName, int timeLapseBaseTimeStep = NO_TIME_LAPSE)
explicit RigEclipseResultAddress(RiaDefines::ResultCatType type, const QString& resultName, int timeLapseBaseTimeStep = NO_TIME_LAPSE, int differenceCaseId = NO_CASE_DIFF)
: m_resultCatType(type)
, m_resultName(resultName)
, m_timeLapseBaseFrameIdx(timeLapseBaseTimeStep)
, m_differenceCaseId(differenceCaseId)
{}
bool isValid() const
{
if (m_resultName.isEmpty() || m_resultName == RiaDefines::undefinedResultName())
@@ -54,12 +59,20 @@ public:
static const int ALL_TIME_LAPSES = -2;
static const int NO_TIME_LAPSE = -1;
static const int NO_CASE_DIFF = -1;
bool isTimeLapse() const { return m_timeLapseBaseFrameIdx > NO_TIME_LAPSE;}
bool representsAllTimeLapses() const { return m_timeLapseBaseFrameIdx == ALL_TIME_LAPSES;}
bool hasDifferenceCase() const { return m_differenceCaseId > NO_CASE_DIFF; }
bool operator< (const RigEclipseResultAddress& other ) const
{
if (m_differenceCaseId != other.m_differenceCaseId)
{
return (m_differenceCaseId < other.m_differenceCaseId);
}
if (m_timeLapseBaseFrameIdx != other.m_timeLapseBaseFrameIdx)
{
return (m_timeLapseBaseFrameIdx < other.m_timeLapseBaseFrameIdx);
@@ -77,7 +90,8 @@ public:
{
if ( m_resultCatType != other.m_resultCatType
|| m_resultName != other.m_resultName
|| m_timeLapseBaseFrameIdx != other.m_timeLapseBaseFrameIdx)
|| m_timeLapseBaseFrameIdx != other.m_timeLapseBaseFrameIdx
|| m_differenceCaseId != other.m_differenceCaseId)
{
return false;
}
@@ -87,8 +101,9 @@ public:
RiaDefines::ResultCatType m_resultCatType;
QString m_resultName;
int m_timeLapseBaseFrameIdx;
int m_differenceCaseId;
};