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

#4571 WIP: Multiplot grid cell plotting

Browse Source 
Basics working. Missing single plot and normalizing
This commit is contained in:
Jacob Støren 2019-08-21 16:36:17 +02:00 committed by Gaute Lindkvist
parent 80f0273437
commit 889577400a
6 changed files with 394 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

433
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp
View File

@ -44,6 +44,15 @@
#include <QStringList>
#include <QFileInfo>
#include <QRegularExpression>
#include "RiaImportEclipseCaseTools.h"
#include "RimEclipseCase.h"
#include "RimGridTimeHistoryCurve.h"
#include "WellLogCommands/RicWellLogPlotCurveFeatureImpl.h"
#include "RimEclipseResultCase.h"
#include "RimOilField.h"
#include "RimEclipseCaseCollection.h"
#include "RigEclipseResultAddress.h"
//--------------------------------------------------------------------------------------------------
///
@ -162,6 +171,119 @@ RimSummaryCurve* createHistoryCurve(const RifEclipseSummaryAddress& addr, RimSu
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RigGridCellResultAddress
{
public:
RigGridCellResultAddress()
: gridIndex(-1)
, i(-1)
, j(-1)
, k(-1)
{}
RigGridCellResultAddress(size_t gridIndex,
size_t i,
size_t j,
size_t k,
const RigEclipseResultAddress & eclipseResultAddress)
: gridIndex(gridIndex)
, i(i)
, j(j)
, k(k)
, eclipseResultAddress(eclipseResultAddress)
{}
// Using zero based ijk
size_t gridIndex;
size_t i;
size_t j;
size_t k;
RigEclipseResultAddress eclipseResultAddress;
};
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RigGridCellResultAddress> createGridCellAddressesFromFilter(const QString& text)
{
std::vector<RigGridCellResultAddress> addresses;
QStringList addressParts = text.split(":");
if (addressParts.size() > 1)
{
QString resultVarName = addressParts[0];
size_t gridIdx = 0;
if (addressParts.size() > 2)
{
gridIdx = addressParts[1].toULong();
}
QString ijkText = addressParts.back();
QStringList ijkTextParts = ijkText.split(",");
if (ijkTextParts.size() == 3)
{
bool isOk = true;
bool allOk = true;
size_t i = ijkTextParts[0].toULong(&isOk);
allOk &= isOk;
size_t j = ijkTextParts[1].toULong(&isOk);
allOk &= isOk;
size_t k = ijkTextParts[2].toULong(&isOk);
allOk &= isOk;
if (allOk)
{
addresses.emplace_back(RigGridCellResultAddress(gridIdx, i-1, j-1, k-1, RigEclipseResultAddress(resultVarName )));
}
}
}
return addresses;
}
std::vector<RimEclipseCase*> openEclipseCasesForCellPlotting(QStringList gridFileNames)
{
std::vector<RimEclipseCase*> openedCases;
RiaApplication* app = RiaApplication::instance();
RimProject* project = app->project();
RimEclipseCaseCollection* analysisModels = project->activeOilField()->analysisModels();
for ( const QString& fileName: gridFileNames )
{
QFileInfo gridFileInfo(fileName);
if (!gridFileInfo.exists()) continue;
QString caseName = gridFileInfo.completeBaseName();
RimEclipseResultCase* rimResultReservoir = new RimEclipseResultCase();
rimResultReservoir->setCaseInfo(caseName, fileName);
analysisModels->cases.push_back(rimResultReservoir);
if ( !rimResultReservoir->openReserviorCase() )
{
analysisModels->removeCaseFromAllGroups(rimResultReservoir);
delete rimResultReservoir;
continue;
}
else
{
openedCases.push_back(rimResultReservoir);
}
}
analysisModels->updateConnectedEditors();
return openedCases;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -170,8 +292,9 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine(const QString
// Split arguments in options, vectors and filenames
QStringList options;
QStringList summaryAddressFilters;
QStringList summaryFiles;
QStringList allCurveAddressFilters;
QStringList summaryFileNames;
QStringList gridFileNames;
QString ensembleColoringParameter;
std::set<QString> validOptions = {"-help", "-h", "-nl", "-s", "-n", "-e", "-c", "-cl"};
@ -226,20 +349,23 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine(const QString
{
RiaEclipseFileNameTools nameTool(arguments[optionIdx]);
QString smSpecFileName = nameTool.findRelatedSummarySpecFile();
if (smSpecFileName != "")
QString gridFileName = nameTool.findRelatedGridFile();
if (smSpecFileName != "" || gridFileName != "")
{
summaryFiles.push_back(smSpecFileName);
if (smSpecFileName != "") summaryFileNames.push_back(smSpecFileName);
if (gridFileName != "") gridFileNames.push_back(gridFileName);
}
else
{
summaryAddressFilters.push_back(arguments[optionIdx]) ;
allCurveAddressFilters.push_back(arguments[optionIdx]);
}
}
}
if ( summaryAddressFilters.empty() )
if ( allCurveAddressFilters.empty() )
{
RiaLogging::error("Needs at least one summary vector to create a plot.");
RiaLogging::error("Needs at least one vector to create a plot.");
}
bool hideLegend = options.contains("-nl");
@ -265,155 +391,237 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine(const QString
std::vector<RimSummaryCase*> summaryCasesToUse;
if ( summaryFiles.size() )
if ( summaryFileNames.size() )
{
RicImportSummaryCasesFeature::createSummaryCasesFromFiles(summaryFiles, &summaryCasesToUse, isEnsembleMode);
RicImportSummaryCasesFeature::createSummaryCasesFromFiles(summaryFileNames, &summaryCasesToUse, isEnsembleMode);
RicImportSummaryCasesFeature::addSummaryCases(summaryCasesToUse);
RiaApplication::instance()->setLastUsedDialogDirectory(RiaDefines::defaultDirectoryLabel(RiaDefines::ECLIPSE_SUMMARY_FILE),
QFileInfo(summaryFiles[0]).absolutePath());
QFileInfo(summaryFileNames[0]).absolutePath());
}
// Sort in summary and grid curve addresses
QStringList gridResultAddressFilters;
QStringList summaryAddressFilters;
if ( summaryCasesToUse.size() )
{
RimSummaryPlot* lastPlotCreated = nullptr;
RimSummaryPlotCollection* sumPlotColl = RiaApplication::instance()->project()->mainPlotCollection()->summaryPlotCollection();
RimSummaryCaseCollection* ensemble = nullptr;
if (isEnsembleMode) ensemble = RicCreateSummaryCaseCollectionFeature::groupSummaryCases(summaryCasesToUse, "Ensemble", true);
const std::set<RifEclipseSummaryAddress>& addrs = summaryCasesToUse[0]->summaryReader()->allResultAddresses();
std::vector<bool> usedFilters;
std::set<RifEclipseSummaryAddress> setToInsertFilteredAddressesIn;
filteredSummaryAdressesFromCase(allCurveAddressFilters, addrs, &setToInsertFilteredAddressesIn, &usedFilters);
if ( isSinglePlot )
QRegularExpression gridAddressPattern("^[A-Z]+:[0-9]+,[0-9]+,[0-9]+$");
for ( int filterIdx = 0; filterIdx < allCurveAddressFilters.size(); ++filterIdx )
{
RimSummaryPlot* newPlot = sumPlotColl->createSummaryPlotWithAutoTitle();
if ( isEnsembleMode )
const QString& address = allCurveAddressFilters[filterIdx];
if ( usedFilters[filterIdx] )
{
std::set<RifEclipseSummaryAddress> filteredAdressesFromCases = applySummaryAddressFiltersToCases(summaryCasesToUse,
summaryAddressFilters);
for ( const auto & addr : filteredAdressesFromCases )
{
RimEnsembleCurveSet* curveSet = new RimEnsembleCurveSet();
curveSet->setSummaryCaseCollection(ensemble);
curveSet->setSummaryAddress(addr);
if ( ensembleColoringStyle == PARAMETER || ensembleColoringStyle == LOG_PARAMETER )
{
curveSet->setColorMode(RimEnsembleCurveSet::BY_ENSEMBLE_PARAM);
curveSet->setEnsembleParameter(ensembleColoringParameter);
if ( ensembleColoringStyle == LOG_PARAMETER )
{
curveSet->legendConfig()->setMappingMode(RimRegularLegendConfig::LOG10_CONTINUOUS);
}
}
newPlot->ensembleCurveSetCollection()->addCurveSet(curveSet);
if (addHistoryCurves)
{
RimSummaryCurve* historyCurve = createHistoryCurve(addr, summaryCasesToUse[0]);
if (historyCurve) newPlot->addCurveNoUpdate(historyCurve);
}
}
summaryAddressFilters.push_back(address);
}
else
{
for ( RimSummaryCase* sumCase : summaryCasesToUse )
if ( gridAddressPattern.match(address).hasMatch() )
{
RicSummaryPlotFeatureImpl::addCurvesFromAddressFiltersToPlot(summaryAddressFilters, newPlot, sumCase, addHistoryCurves);
addHistoryCurves = false;
gridResultAddressFilters.push_back(address);
}
else
{
RiaLogging::warning("No summary or restart vectors matched \"" + address + "\"");
}
}
lastPlotCreated = newPlot;
newPlot->showLegend(!hideLegend);
newPlot->setNormalizationEnabled(isNormalizedY);
newPlot->applyDefaultCurveAppearances();
newPlot->loadDataAndUpdate();
sumPlotColl->updateConnectedEditors();
RiuPlotMainWindowTools::setExpanded(newPlot);
RiuPlotMainWindowTools::selectAsCurrentItem(newPlot);
}
else // Multiplot, one for each separate summary address
}
if ( summaryCasesToUse.size() )
{
if ( summaryAddressFilters.size() )
{
RimSummaryPlotCollection* sumPlotColl = RiaApplication::instance()->project()->mainPlotCollection()->summaryPlotCollection();
RimSummaryPlot* lastPlotCreated = nullptr;
RimSummaryCaseCollection* ensemble = nullptr;
if ( isEnsembleMode ) ensemble = RicCreateSummaryCaseCollectionFeature::groupSummaryCases(summaryCasesToUse, "Ensemble", true);
std::set<RifEclipseSummaryAddress> filteredAdressesFromCases = applySummaryAddressFiltersToCases(summaryCasesToUse,
summaryAddressFilters);
for ( const auto & addr : filteredAdressesFromCases )
if ( isSinglePlot )
{
std::vector<RimSummaryCurve*> createdCurves;
std::vector<RimEnsembleCurveSet*> createdEnsembleCurveSets;
RimSummaryPlot* newPlot = sumPlotColl->createSummaryPlotWithAutoTitle();
if ( isEnsembleMode )
{
RimEnsembleCurveSet* curveSet = new RimEnsembleCurveSet();
curveSet->setSummaryCaseCollection(ensemble);
curveSet->setSummaryAddress(addr);
if ( ensembleColoringStyle == PARAMETER || ensembleColoringStyle == LOG_PARAMETER )
std::set<RifEclipseSummaryAddress> filteredAdressesFromCases = applySummaryAddressFiltersToCases(summaryCasesToUse,
summaryAddressFilters);
for ( const auto & addr : filteredAdressesFromCases )
{
curveSet->setColorMode(RimEnsembleCurveSet::BY_ENSEMBLE_PARAM);
curveSet->setEnsembleParameter(ensembleColoringParameter);
if ( ensembleColoringStyle == LOG_PARAMETER )
RimEnsembleCurveSet* curveSet = new RimEnsembleCurveSet();
curveSet->setSummaryCaseCollection(ensemble);
curveSet->setSummaryAddress(addr);
if ( ensembleColoringStyle == PARAMETER || ensembleColoringStyle == LOG_PARAMETER )
{
curveSet->legendConfig()->setMappingMode(RimRegularLegendConfig::LOG10_CONTINUOUS);
curveSet->setColorMode(RimEnsembleCurveSet::BY_ENSEMBLE_PARAM);
curveSet->setEnsembleParameter(ensembleColoringParameter);
if ( ensembleColoringStyle == LOG_PARAMETER )
{
curveSet->legendConfig()->setMappingMode(RimRegularLegendConfig::LOG10_CONTINUOUS);
}
}
newPlot->ensembleCurveSetCollection()->addCurveSet(curveSet);
if ( addHistoryCurves )
{
RimSummaryCurve* historyCurve = createHistoryCurve(addr, summaryCasesToUse[0]);
if ( historyCurve ) newPlot->addCurveNoUpdate(historyCurve);
}
}
createdEnsembleCurveSets.push_back(curveSet);
}
else
{
for ( RimSummaryCase* sumCase : summaryCasesToUse )
{
const std::set<RifEclipseSummaryAddress>& allAddrsInCase = sumCase->summaryReader()->allResultAddresses();
if ( allAddrsInCase.count(addr) )
RicSummaryPlotFeatureImpl::addCurvesFromAddressFiltersToPlot(summaryAddressFilters, newPlot, sumCase, addHistoryCurves);
addHistoryCurves = false;
}
}
lastPlotCreated = newPlot;
newPlot->showLegend(!hideLegend);
newPlot->setNormalizationEnabled(isNormalizedY);
newPlot->applyDefaultCurveAppearances();
newPlot->loadDataAndUpdate();
sumPlotColl->updateConnectedEditors();
RiuPlotMainWindowTools::setExpanded(newPlot);
RiuPlotMainWindowTools::selectAsCurrentItem(newPlot);
}
else // Multiplot, one for each separate summary address
{
std::set<RifEclipseSummaryAddress> filteredAdressesFromCases = applySummaryAddressFiltersToCases(summaryCasesToUse,
summaryAddressFilters);
for ( const auto & addr : filteredAdressesFromCases )
{
std::vector<RimSummaryCurve*> createdCurves;
std::vector<RimEnsembleCurveSet*> createdEnsembleCurveSets;
if ( isEnsembleMode )
{
RimEnsembleCurveSet* curveSet = new RimEnsembleCurveSet();
curveSet->setSummaryCaseCollection(ensemble);
curveSet->setSummaryAddress(addr);
if ( ensembleColoringStyle == PARAMETER || ensembleColoringStyle == LOG_PARAMETER )
{
RimSummaryCurve* newCurve = new RimSummaryCurve();
newCurve->setSummaryCaseY(sumCase);
newCurve->setSummaryAddressYAndApplyInterpolation(addr);
createdCurves.push_back(newCurve);
curveSet->setColorMode(RimEnsembleCurveSet::BY_ENSEMBLE_PARAM);
curveSet->setEnsembleParameter(ensembleColoringParameter);
if ( ensembleColoringStyle == LOG_PARAMETER )
{
curveSet->legendConfig()->setMappingMode(RimRegularLegendConfig::LOG10_CONTINUOUS);
}
}
createdEnsembleCurveSets.push_back(curveSet);
}
else
{
for ( RimSummaryCase* sumCase : summaryCasesToUse )
{
const std::set<RifEclipseSummaryAddress>& allAddrsInCase = sumCase->summaryReader()->allResultAddresses();
if ( allAddrsInCase.count(addr) )
{
RimSummaryCurve* newCurve = new RimSummaryCurve();
newCurve->setSummaryCaseY(sumCase);
newCurve->setSummaryAddressYAndApplyInterpolation(addr);
createdCurves.push_back(newCurve);
}
}
}
}
if ( addHistoryCurves )
{
RimSummaryCurve* historyCurve = createHistoryCurve(addr, summaryCasesToUse[0]);
if (historyCurve) createdCurves.push_back(historyCurve);
}
if ( createdCurves.size() || createdEnsembleCurveSets.size() )
{
RimSummaryPlot* newPlot = sumPlotColl->createSummaryPlotWithAutoTitle();
for ( auto curve : createdCurves )
if ( addHistoryCurves )
{
newPlot->addCurveNoUpdate(curve);
RimSummaryCurve* historyCurve = createHistoryCurve(addr, summaryCasesToUse[0]);
if ( historyCurve ) createdCurves.push_back(historyCurve);
}
for ( auto curveSet: createdEnsembleCurveSets )
if ( createdCurves.size() || createdEnsembleCurveSets.size() )
{
newPlot->ensembleCurveSetCollection()->addCurveSet(curveSet);
RimSummaryPlot* newPlot = sumPlotColl->createSummaryPlotWithAutoTitle();
for ( auto curve : createdCurves )
{
newPlot->addCurveNoUpdate(curve);
}
for ( auto curveSet: createdEnsembleCurveSets )
{
newPlot->ensembleCurveSetCollection()->addCurveSet(curveSet);
}
newPlot->showLegend(!hideLegend);
newPlot->setNormalizationEnabled(isNormalizedY);
newPlot->applyDefaultCurveAppearances();
newPlot->loadDataAndUpdate();
lastPlotCreated = newPlot;
}
newPlot->showLegend(!hideLegend);
newPlot->setNormalizationEnabled(isNormalizedY);
newPlot->applyDefaultCurveAppearances();
newPlot->loadDataAndUpdate();
lastPlotCreated = newPlot;
}
}
}
sumPlotColl->updateConnectedEditors();
sumPlotColl->updateConnectedEditors();
if ( lastPlotCreated )
if ( lastPlotCreated )
{
RiuPlotMainWindowTools::setExpanded(lastPlotCreated);
RiuPlotMainWindowTools::selectAsCurrentItem(lastPlotCreated);
RiuPlotMainWindowTools::showPlotMainWindow();
RiuMainWindow::instance()->close();
}
}
// Grid Cell Result vectors
if ( gridResultAddressFilters.size() )
{
RiuPlotMainWindowTools::setExpanded(lastPlotCreated);
RiuPlotMainWindowTools::selectAsCurrentItem(lastPlotCreated);
// Todo: Use identical grid case import if -e -c or -cl
std::vector<RimEclipseCase*> gridCasesToPlotFrom = openEclipseCasesForCellPlotting(gridFileNames);
RimSummaryPlotCollection* sumPlotColl = RiaApplication::instance()->project()->mainPlotCollection()->summaryPlotCollection();
for (const QString& gridAddressFilter : gridResultAddressFilters)
{
std::vector<RigGridCellResultAddress> cellResAddrs = createGridCellAddressesFromFilter(gridAddressFilter);
for (RigGridCellResultAddress cellResAddr : cellResAddrs )
{
RimSummaryPlot* newPlot = sumPlotColl->createSummaryPlotWithAutoTitle();
for ( RimEclipseCase* eclCase: gridCasesToPlotFrom )
{
RimGridTimeHistoryCurve* newCurve = new RimGridTimeHistoryCurve();
newCurve->setFromEclipseCellAndResult(eclCase,
cellResAddr.gridIndex,
cellResAddr.i,
cellResAddr.j,
cellResAddr.k,
cellResAddr.eclipseResultAddress);
newCurve->setLineThickness(2);
cvf::Color3f curveColor = RicWellLogPlotCurveFeatureImpl::curveColorFromTable(newPlot->curveCount());
newCurve->setColor(curveColor);
newPlot->addGridTimeHistoryCurve(newCurve);
newPlot->showLegend(!hideLegend);
newPlot->setNormalizationEnabled(isNormalizedY);
newPlot->applyDefaultCurveAppearances();
newPlot->loadDataAndUpdate();
}
}
}
sumPlotColl->updateConnectedEditors();
RiuPlotMainWindowTools::showPlotMainWindow();
RiuMainWindow::instance()->close();
}
@ -504,6 +712,9 @@ std::vector<RimSummaryCurve*> RicSummaryPlotFeatureImpl::addCurvesFromAddressFil
return createdCurves;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryPlotFeatureImpl::filteredSummaryAdressesFromCase(const QStringList& curveFilters,
const std::set<RifEclipseSummaryAddress>& allAddressesInCase,
std::set<RifEclipseSummaryAddress>* setToInsertFilteredAddressesIn,

20
ApplicationCode/ProjectDataModel/RimEclipseGeometrySelectionItem.cpp
View File

@ -19,6 +19,8 @@
#include "RimEclipseGeometrySelectionItem.h"
#include "RigTimeHistoryResultAccessor.h"
#include "RigEclipseCaseData.h"
#include "RigGridBase.h"
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
@ -61,6 +63,24 @@ void RimEclipseGeometrySelectionItem::setFromSelectionItem(const RiuEclipseSelec
m_eclipseCase = selectionItem->m_view->eclipseCase();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseGeometrySelectionItem::setFromCaseGridAndIJK(RimEclipseCase* eclipseCase,
size_t gridIndex,
size_t i,
size_t j,
size_t k)
{
m_eclipseCase = eclipseCase;
m_gridIndex = gridIndex;
size_t lgrCellIndex = eclipseCase->eclipseCaseData()->grid(gridIndex)->cellIndexFromIJK(i, j, k);
size_t reservoirCellIndex = eclipseCase->eclipseCaseData()->grid(gridIndex)->reservoirCellIndex(lgrCellIndex);
m_cellIndex = reservoirCellIndex;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

6
ApplicationCode/ProjectDataModel/RimEclipseGeometrySelectionItem.h
View File

@ -39,7 +39,11 @@ public:
~RimEclipseGeometrySelectionItem() override;
void setFromSelectionItem(const RiuEclipseSelectionItem* selectionItem);
void setFromCaseGridAndIJK(RimEclipseCase* eclipseCase,
size_t gridIndex,
size_t i,
size_t j,
size_t k);
QString geometrySelectionText() const override;
RimEclipseCase* eclipseCase() const;

21
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@ -31,6 +31,7 @@
#include "RigEclipseCaseData.h"
#include "RigFlowDiagResultAddress.h"
#include "RigFlowDiagResults.h"
#include "RigEclipseResultInfo.h"
#include "Rim3dView.h"
#include "Rim3dWellLogCurve.h"
@ -763,21 +764,31 @@ RigEclipseResultAddress RimEclipseResultDefinition::eclipseResultAddress() const
//--------------------------------------------------------------------------------------------------
void RimEclipseResultDefinition::setFromEclipseResultAddress(const RigEclipseResultAddress& address)
{
m_resultType = address.m_resultCatType;
m_resultVariable = address.m_resultName;
m_timeLapseBaseTimestep = address.m_timeLapseBaseFrameIdx;
RigEclipseResultAddress canonizedAddress = address;
if (address.hasDifferenceCase())
const RigCaseCellResultsData* gridCellResults = this->currentGridCellResults();
if (gridCellResults)
{
canonizedAddress = gridCellResults->resultInfo(address)->eclipseResultAddress();
}
m_resultType = canonizedAddress.m_resultCatType;
m_resultVariable = canonizedAddress.m_resultName;
m_timeLapseBaseTimestep = canonizedAddress.m_timeLapseBaseFrameIdx;
if (canonizedAddress.hasDifferenceCase())
{
auto eclipseCases = RiaApplication::instance()->project()->eclipseCases();
for (RimEclipseCase* c : eclipseCases)
{
if (c && c->caseId() == address.m_differenceCaseId)
if (c && c->caseId() == canonizedAddress.m_differenceCaseId)
{
m_differenceCase = c;
}
}
}
this->updateUiFieldsFromActiveResult();
}
//--------------------------------------------------------------------------------------------------

24
ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.cpp
View File

@ -135,6 +135,30 @@ void RimGridTimeHistoryCurve::setFromSelectionItem(const RiuSelectionItem* selec
updateResultDefinitionFromCase();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridTimeHistoryCurve::setFromEclipseCellAndResult(RimEclipseCase* eclCase,
size_t gridIdx,
size_t i,
size_t j,
size_t k,
const RigEclipseResultAddress& resAddr)
{
delete m_geometrySelectionItem();
delete m_eclipseResultDefinition();
delete m_geoMechResultDefinition();
m_eclipseResultDefinition = new RimEclipseResultDefinition;
m_eclipseResultDefinition->setEclipseCase(eclCase);
m_eclipseResultDefinition->setFromEclipseResultAddress(resAddr);
RimEclipseGeometrySelectionItem* geomSelectionItem = new RimEclipseGeometrySelectionItem;
m_geometrySelectionItem = geomSelectionItem;
geomSelectionItem->setFromCaseGridAndIJK(eclCase, gridIdx, i, j, k);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

7
ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.h
View File

@ -36,6 +36,7 @@ class RimGeoMechGeometrySelectionItem;
class RimGeometrySelectionItem;
class RiuFemTimeHistoryResultAccessor;
class RiuSelectionItem;
class RigEclipseResultAddress;
//==================================================================================================
///
@ -51,6 +52,12 @@ public:
~RimGridTimeHistoryCurve() override;
void setFromSelectionItem(const RiuSelectionItem* selectionItem);
void setFromEclipseCellAndResult(RimEclipseCase* eclCase,
size_t gridIdx,
size_t i,
size_t j,
size_t k,
const RigEclipseResultAddress& resAddr);
RiaDefines::PlotAxis yAxis() const;
void setYAxis(RiaDefines::PlotAxis plotAxis);