#4571 WIP: Multiplot grid cell plotting

Basics working. Missing single plot and normalizing

ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp

@@ -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 allCurveAddressFilters;
-    QStringList summaryFiles;
+    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;
+        const std::set<RifEclipseSummaryAddress>&  addrs = summaryCasesToUse[0]->summaryReader()->allResultAddresses();
-        RimSummaryPlotCollection* sumPlotColl = RiaApplication::instance()->project()->mainPlotCollection()->summaryPlotCollection();
+        std::vector<bool> usedFilters;
-        RimSummaryCaseCollection* ensemble = nullptr;
+        std::set<RifEclipseSummaryAddress> setToInsertFilteredAddressesIn;
-        if (isEnsembleMode) ensemble = RicCreateSummaryCaseCollectionFeature::groupSummaryCases(summaryCasesToUse, "Ensemble", true);
+        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();
+            const QString& address = allCurveAddressFilters[filterIdx];
-
+            if ( usedFilters[filterIdx] )
-            if ( isEnsembleMode )
             {
-                std::set<RifEclipseSummaryAddress> filteredAdressesFromCases = applySummaryAddressFiltersToCases(summaryCasesToUse, 
+                summaryAddressFilters.push_back(address);
-                                                                                                                 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);
-                    }
-                }
             }
             else
             {
-                for ( RimSummaryCase* sumCase : summaryCasesToUse )
+                if ( gridAddressPattern.match(address).hasMatch() )
                 {
-                    RicSummaryPlotFeatureImpl::addCurvesFromAddressFiltersToPlot(summaryAddressFilters, newPlot, sumCase, addHistoryCurves);
+                    gridResultAddressFilters.push_back(address);
-                    addHistoryCurves = false;
+                }
+                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, 
+            if ( isSinglePlot )
-                                                                                                             summaryAddressFilters);
-
-            for ( const auto & addr : filteredAdressesFromCases )
             {
-                std::vector<RimSummaryCurve*> createdCurves;
+                RimSummaryPlot* newPlot = sumPlotColl->createSummaryPlotWithAutoTitle();
-                std::vector<RimEnsembleCurveSet*> createdEnsembleCurveSets;
+
                 if ( isEnsembleMode )
                 {
-                    RimEnsembleCurveSet* curveSet = new RimEnsembleCurveSet();
+                    std::set<RifEclipseSummaryAddress> filteredAdressesFromCases = applySummaryAddressFiltersToCases(summaryCasesToUse,
-
+                                                                                                                     summaryAddressFilters);
-                    curveSet->setSummaryCaseCollection(ensemble);
+                    for ( const auto & addr : filteredAdressesFromCases )
-                    curveSet->setSummaryAddress(addr);
-                    if ( ensembleColoringStyle == PARAMETER || ensembleColoringStyle == LOG_PARAMETER )
                     {
-                        curveSet->setColorMode(RimEnsembleCurveSet::BY_ENSEMBLE_PARAM);
+                        RimEnsembleCurveSet* curveSet = new RimEnsembleCurveSet();
-                        curveSet->setEnsembleParameter(ensembleColoringParameter);
+
-                        if ( ensembleColoringStyle == LOG_PARAMETER )
+                        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();
+                        RicSummaryPlotFeatureImpl::addCurvesFromAddressFiltersToPlot(summaryAddressFilters, newPlot, sumCase, addHistoryCurves);
-                        if ( allAddrsInCase.count(addr) )
+                        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();
+                            curveSet->setColorMode(RimEnsembleCurveSet::BY_ENSEMBLE_PARAM);
-                            newCurve->setSummaryCaseY(sumCase);
+                            curveSet->setEnsembleParameter(ensembleColoringParameter);
-                            newCurve->setSummaryAddressYAndApplyInterpolation(addr);
+                            if ( ensembleColoringStyle == LOG_PARAMETER )
-                            createdCurves.push_back(newCurve);
+                            {
+                                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 )
+                    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 )
                     {
-                        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);
+            // Todo: Use identical grid case import if -e -c or -cl
-            RiuPlotMainWindowTools::selectAsCurrentItem(lastPlotCreated);
+
+            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,

ApplicationCode/ProjectDataModel/RimEclipseGeometrySelectionItem.cpp

@@ -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;
+
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/RimEclipseGeometrySelectionItem.h

@@ -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;

ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp

@@ -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;
+    RigEclipseResultAddress canonizedAddress = address;
-    m_resultVariable        = address.m_resultName;
-    m_timeLapseBaseTimestep = address.m_timeLapseBaseFrameIdx;
 
-    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();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.cpp

@@ -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);
+
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.h

@@ -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);