Merge branch 'dev'

ApplicationCode/Commands/EclipseCommands/RicEclipsePropertyFilterFeatureImpl.cpp

@@ -117,9 +117,8 @@ void RicEclipsePropertyFilterFeatureImpl::setDefaults(RimEclipsePropertyFilter*
     CVF_ASSERT(reservoirView);
 
     propertyFilter->resultDefinition->setEclipseCase(reservoirView->eclipseCase());
-    propertyFilter->resultDefinition->setResultVariable(reservoirView->cellResult->resultVariable());
-    propertyFilter->resultDefinition->setPorosityModel(reservoirView->cellResult->porosityModel());
-    propertyFilter->resultDefinition->setResultType(reservoirView->cellResult->resultType());
+    propertyFilter->resultDefinition->simpleCopy(reservoirView->cellResult);
+
     propertyFilter->resultDefinition->loadResult();
     propertyFilter->setToDefaultValues();
     propertyFilter->updateFilterName();

ApplicationCode/Commands/RicExportMultipleSnapshotsFeature.cpp

@@ -19,12 +19,30 @@
 #include "RicExportMultipleSnapshotsFeature.h"
 
 #include "RiaApplication.h"
+
+#include "RicSnapshotViewToClipboardFeature.h"
+
+#include "RimCase.h"
+#include "RimCellRangeFilter.h"
+#include "RimCellRangeFilterCollection.h"
+#include "RimEclipseCase.h"
+#include "RimEclipseView.h"
+#include "RimGeoMechCase.h"
+#include "RimGeoMechView.h"
+#include "RimMultiSnapshotDefinition.h"
 #include "RimProject.h"
+#include "RimView.h"
+
 #include "RiuExportMultipleSnapshotsWidget.h"
+#include "RiuViewer.h"
 
 #include "cafCmdExecCommandManager.h"
+#include "cafFrameAnimationControl.h"
+#include "cafUtils.h"
 
 #include <QAction>
+#include <QDebug>
+#include <QDir>
 
 
 CAF_CMD_SOURCE_INIT(RicExportMultipleSnapshotsFeature, "RicExportMultipleSnapshotsFeature");
@@ -66,3 +84,167 @@ void RicExportMultipleSnapshotsFeature::setupActionLook(QAction* actionToSetup)
     //actionToSetup->setIcon(QIcon(":/Save.png"));
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicExportMultipleSnapshotsFeature::exportMultipleSnapshots(const QString& folder, RimProject* project)
+{
+    if (!project) return;
+
+    QDir snapshotPath(folder);
+    if (!snapshotPath.exists())
+    {
+        if (!snapshotPath.mkpath(".")) return;
+    }
+    
+    for (RimMultiSnapshotDefinition* msd : project->multiSnapshotDefinitions())
+    {
+        RimView* rimView = msd->viewObject();
+        if (!rimView) continue;
+        if (!rimView->viewer()) continue;
+        
+        int initialFramIndex = rimView->viewer()->currentFrameIndex();
+
+        exportViewVariationsToFolder(rimView, msd, folder);
+
+        for (RimCase* rimCase : msd->additionalCases())
+        {
+            RimView* copyOfView = dynamic_cast<RimView*>(rimView->xmlCapability()->copyByXmlSerialization(caf::PdmDefaultObjectFactory::instance()));
+
+            RimEclipseCase* eclCase = dynamic_cast<RimEclipseCase*>(rimCase);
+            if (eclCase)
+            {
+                RimEclipseView* eclView = dynamic_cast<RimEclipseView*>(copyOfView);
+                CVF_ASSERT(eclView);
+
+                eclCase->reservoirViews().push_back(eclView);
+
+                eclView->setEclipseCase(eclCase);
+
+                // Resolve references after reservoir view has been inserted into Rim structures
+                // Intersections referencing a well path/ simulation well requires this
+                // TODO: initAfterReadRecursively can probably be removed
+                eclView->initAfterReadRecursively();
+                eclView->resolveReferencesRecursively();
+
+                eclView->loadDataAndUpdate();
+
+                exportViewVariationsToFolder(eclView, msd, folder);
+
+                eclCase->reservoirViews().removeChildObject(eclView);
+            }
+
+            RimGeoMechCase* geomCase = dynamic_cast<RimGeoMechCase*>(rimCase);
+            if (geomCase)
+            {
+                RimGeoMechView* geoMechView = dynamic_cast<RimGeoMechView*>(copyOfView);
+                CVF_ASSERT(geoMechView);
+
+                geomCase->geoMechViews().push_back(geoMechView);
+
+                geoMechView->setGeoMechCase(geomCase);
+
+                // Resolve references after reservoir view has been inserted into Rim structures
+                // Intersections referencing a well path/ simulation well requires this
+                // TODO: initAfterReadRecursively can probably be removed
+                geoMechView->initAfterReadRecursively();
+                geoMechView->resolveReferencesRecursively();
+
+                geoMechView->loadDataAndUpdate();
+
+                exportViewVariationsToFolder(geoMechView, msd, folder);
+
+                geomCase->geoMechViews().removeChildObject(geoMechView);
+            }
+
+            delete copyOfView;
+        }
+
+        // Set view back to initial state
+        rimView->viewer()->setCurrentFrame(initialFramIndex);
+        rimView->viewer()->animationControl()->setCurrentFrameOnly(initialFramIndex);
+
+        rimView->scheduleCreateDisplayModelAndRedraw();
+     }
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicExportMultipleSnapshotsFeature::exportViewVariationsToFolder(RimView* rimView, RimMultiSnapshotDefinition* msd, const QString& folder)
+{
+    RimCase* rimCase = rimView->ownerCase();
+    CVF_ASSERT(rimCase);
+
+    RiuViewer* viewer = rimView->viewer();
+    QStringList timeSteps = rimCase->timeStepStrings();
+
+    for (int i = msd->timeStepStart(); i <= msd->timeStepEnd(); i++)
+    {
+        QString timeStepIndexString = QString("%1").arg(i, 2, 10, QLatin1Char('0'));
+
+        QString timeStepString = timeStepIndexString + "_" + timeSteps[i].replace(".", "-");
+
+        if (viewer)
+        {
+            viewer->setCurrentFrame(i);
+            viewer->animationControl()->setCurrentFrameOnly(i);
+        }
+
+        if (msd->sliceDirection == RimMultiSnapshotDefinition::NO_RANGEFILTER)
+        {
+            QString fileName = rimCase->caseUserDescription() + "_" + rimView->name() + "_" + timeStepString;
+            fileName.replace(" ", "-");
+            QString absoluteFileName = caf::Utils::constructFullFileName(folder, fileName, ".png");
+
+            QCoreApplication::instance()->processEvents();
+
+            RicSnapshotViewToFileFeature::saveSnapshotAs(absoluteFileName, rimView);
+        }
+        else
+        {
+            RimCellRangeFilter* rangeFilter = new RimCellRangeFilter;
+            rimView->rangeFilterCollection()->rangeFilters.push_back(rangeFilter);
+
+            bool rangeFilterInitState = rimView->rangeFilterCollection()->isActive();
+            rimView->rangeFilterCollection()->isActive = true;
+
+            for (int i = msd->startSliceIndex(); i <= msd->endSliceIndex(); i++)
+            {
+                QString rangeFilterString = msd->sliceDirection().text() + "-" + QString::number(i);
+                QString fileName = rimCase->caseUserDescription() + "_" + rimView->name() + "_" + timeStepString + "_" + rangeFilterString;
+                fileName.replace(" ", "-");
+
+                rangeFilter->setDefaultValues();
+                if (msd->sliceDirection == RimMultiSnapshotDefinition::RANGEFILTER_I)
+                {
+                    rangeFilter->cellCountI = 1;
+                    rangeFilter->startIndexI = i;
+                }
+                else if (msd->sliceDirection == RimMultiSnapshotDefinition::RANGEFILTER_J)
+                {
+                    rangeFilter->cellCountJ = 1;
+                    rangeFilter->startIndexJ = i;
+                }
+                else if (msd->sliceDirection == RimMultiSnapshotDefinition::RANGEFILTER_K)
+                {
+                    rangeFilter->cellCountK = 1;
+                    rangeFilter->startIndexK = i;
+                }
+
+                rimView->rangeFilterCollection()->updateDisplayModeNotifyManagedViews(rangeFilter);
+                // Make sure the redraw is processed
+                QCoreApplication::instance()->processEvents();
+
+                QString absoluteFileName = caf::Utils::constructFullFileName(folder, fileName, ".png");
+                RicSnapshotViewToFileFeature::saveSnapshotAs(absoluteFileName, rimView);
+            }
+
+            rimView->rangeFilterCollection()->rangeFilters.removeChildObject(rangeFilter);
+            delete rangeFilter;
+
+            rimView->rangeFilterCollection()->isActive = rangeFilterInitState;
+        }
+    }
+}
+

ApplicationCode/Commands/RicExportMultipleSnapshotsFeature.h

@@ -20,6 +20,7 @@
 
 #include "cafCmdFeature.h"
 
+class RimProject;
 
 //==================================================================================================
 /// 
@@ -32,5 +33,11 @@ protected:
     virtual bool isCommandEnabled() override;
     virtual void onActionTriggered( bool isChecked ) override;
     virtual void setupActionLook(QAction* actionToSetup) override;
+
+public:
+    static void exportMultipleSnapshots(const QString& folder, RimProject* project);
+
+    static void exportViewVariationsToFolder(RimView* rimView, RimMultiSnapshotDefinition* msd, const QString& folder);
+
 };
 

ApplicationCode/Commands/RicExportToLasFileFeature.cpp

@@ -24,6 +24,8 @@
 #include "RigLasFileExporter.h"
 #include "RimWellLogCurve.h"
 
+#include "WellLogCommands/RicWellLogPlotCurveFeatureImpl.h"
+
 #include "cafPdmUiPropertyViewDialog.h"
 #include "cafSelectionManager.h"
   
@@ -39,7 +41,7 @@ CAF_CMD_SOURCE_INIT(RicExportToLasFileFeature, "RicExportToLasFileFeature");
 //--------------------------------------------------------------------------------------------------
 bool RicExportToLasFileFeature::isCommandEnabled()
 {
-    return selectedWellLogCurves().size() > 0;
+    return RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves().size() > 0;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -47,7 +49,7 @@ bool RicExportToLasFileFeature::isCommandEnabled()
 //--------------------------------------------------------------------------------------------------
 void RicExportToLasFileFeature::onActionTriggered(bool isChecked)
 {
-    std::vector<RimWellLogCurve*> curves = selectedWellLogCurves();
+    std::vector<RimWellLogCurve*> curves = RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves();
     if (curves.size() == 0) return;
 
     RiaApplication* app = RiaApplication::instance();
@@ -103,39 +105,3 @@ void RicExportToLasFileFeature::setupActionLook(QAction* actionToSetup)
     actionToSetup->setText("Export To LAS Files...");
 }
 
-//--------------------------------------------------------------------------------------------------
-/// 
-//--------------------------------------------------------------------------------------------------
-std::vector<RimWellLogCurve*> RicExportToLasFileFeature::selectedWellLogCurves() const
-{
-    std::set<RimWellLogCurve*> curveSet;
-
-    {
-        std::vector<caf::PdmUiItem*> selectedItems;
-        caf::SelectionManager::instance()->selectedItems(selectedItems);
-
-        for (auto selectedItem : selectedItems)
-        {
-            caf::PdmObjectHandle* objHandle = dynamic_cast<caf::PdmObjectHandle*>(selectedItem);
-            if (objHandle)
-            {
-                std::vector<RimWellLogCurve*> childCurves;
-                objHandle->descendantsIncludingThisOfType(childCurves);
-
-                for (auto curve : childCurves)
-                {
-                    curveSet.insert(curve);
-                }
-            }
-        }
-    }
-
-    std::vector<RimWellLogCurve*> allCurves;
-    for (auto curve : curveSet)
-    {
-        allCurves.push_back(curve);
-    }
-
-    return allCurves;
-}
-

ApplicationCode/Commands/RicExportToLasFileFeature.h

@@ -37,8 +37,5 @@ protected:
     virtual bool isCommandEnabled();
     virtual void onActionTriggered( bool isChecked );
     virtual void setupActionLook( QAction* actionToSetup );
-
-private:
-    std::vector<RimWellLogCurve*> selectedWellLogCurves() const;
 };
 

ApplicationCode/Commands/WellLogCommands/CMakeLists_files.cmake

@@ -18,6 +18,8 @@ ${CEE_CURRENT_LIST_DIR}RicWellLogPlotTrackFeatureImpl.h
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogCurveFeature.h
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogTrackFeature.h
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogPlotFeature.h
+${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeature.h
+${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeatureUi.h
 )
 
 set (SOURCE_GROUP_SOURCE_FILES
@@ -34,6 +36,8 @@ ${CEE_CURRENT_LIST_DIR}RicWellLogPlotTrackFeatureImpl.cpp
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogCurveFeature.cpp
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogTrackFeature.cpp
 ${CEE_CURRENT_LIST_DIR}RicPasteWellLogPlotFeature.cpp
+${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeature.cpp
+${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeatureUi.cpp
 )
 
 list(APPEND CODE_HEADER_FILES

ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeature.cpp

@@ -0,0 +1,98 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016      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 "RicChangeDataSourceFeature.h"
+
+#include "RicChangeDataSourceFeatureUi.h"
+#include "RicWellLogPlotCurveFeatureImpl.h"
+
+#include "RimCase.h"
+#include "RimWellLogCurve.h"
+#include "RimWellLogExtractionCurve.h"
+#include "RimWellPath.h"
+
+#include "cafPdmUiPropertyViewDialog.h"
+
+#include <QAction>
+
+CAF_CMD_SOURCE_INIT(RicChangeDataSourceFeature, "RicChangeDataSourceFeature");
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+bool RicChangeDataSourceFeature::isCommandEnabled()
+{
+    std::vector<RimWellLogExtractionCurve*> extrCurves = extractionCurves();
+
+    return extrCurves.size() > 0;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicChangeDataSourceFeature::onActionTriggered(bool isChecked)
+{
+    std::vector<RimWellLogExtractionCurve*> extrCurves = extractionCurves();
+    if (extrCurves.size() == 0) return;
+
+    RicChangeDataSourceFeatureUi featureUi;
+    featureUi.wellPathToApply = extrCurves[0]->wellPath();
+    featureUi.caseToApply = extrCurves[0]->rimCase();
+
+    caf::PdmUiPropertyViewDialog propertyDialog(nullptr, &featureUi, "Change Data Source for Selected Curves", "");
+    propertyDialog.resize(QSize(500, 200));
+    if (propertyDialog.exec() == QDialog::Accepted)
+    {
+        for (RimWellLogExtractionCurve* extractionCurve : extrCurves)
+        {
+            extractionCurve->setWellPath(featureUi.wellPathToApply);
+            extractionCurve->setCase(featureUi.caseToApply);
+
+            extractionCurve->loadDataAndUpdate();
+        }
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicChangeDataSourceFeature::setupActionLook(QAction* actionToSetup)
+{
+    actionToSetup->setText("Change Data Source");
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<RimWellLogExtractionCurve*> RicChangeDataSourceFeature::extractionCurves()
+{
+    std::vector<RimWellLogExtractionCurve*> extrCurves;
+
+    std::vector<RimWellLogCurve*> curves = RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves();
+
+    for (RimWellLogCurve* c : curves)
+    {
+        if (dynamic_cast<RimWellLogExtractionCurve*>(c))
+        {
+            extrCurves.push_back(dynamic_cast<RimWellLogExtractionCurve*>(c));
+        }
+    }
+
+    return extrCurves;
+}
+

ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeature.h

@@ -0,0 +1,41 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016      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.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "cafCmdFeature.h"
+
+#include <vector>
+
+class RimWellLogExtractionCurve;
+
+//==================================================================================================
+/// 
+//==================================================================================================
+class RicChangeDataSourceFeature : public caf::CmdFeature
+{
+    CAF_CMD_HEADER_INIT;
+
+protected:
+    virtual bool isCommandEnabled() override;
+    virtual void onActionTriggered( bool isChecked ) override;
+    virtual void setupActionLook(QAction* actionToSetup) override;
+
+private:
+    static std::vector<RimWellLogExtractionCurve*> extractionCurves();
+};

ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeatureUi.cpp

@@ -0,0 +1,87 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016      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 "RicChangeDataSourceFeatureUi.h"
+
+#include "RimCase.h"
+#include "RimOilField.h"
+#include "RimProject.h"
+#include "RimWellPath.h"
+#include "RimWellPathCollection.h"
+
+#include "RiaApplication.h"
+
+CAF_PDM_SOURCE_INIT(RicChangeDataSourceFeatureUi, "ChangeDataSourceFeatureUi");
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RicChangeDataSourceFeatureUi::RicChangeDataSourceFeatureUi()
+{
+    CAF_PDM_InitObject("Change Data Source", "", "", "");
+
+    CAF_PDM_InitFieldNoDefault(&wellPathToApply,  "CurveWellPath",  "Well Path", "", "", "");
+    CAF_PDM_InitFieldNoDefault(&caseToApply,      "CurveCase",      "Case", "", "", "");
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+QList<caf::PdmOptionItemInfo> RicChangeDataSourceFeatureUi::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly)
+{
+    QList<caf::PdmOptionItemInfo> optionList;
+
+    if (fieldNeedingOptions == &caseToApply)
+    {
+        RimProject* proj = RiaApplication::instance()->project();
+        
+        std::vector<RimCase*> cases;
+        proj->allCases(cases);
+
+        for (RimCase* c : cases)
+        {
+            optionList.push_back(caf::PdmOptionItemInfo(c->caseUserDescription(), c));
+        }
+    }
+    else if (fieldNeedingOptions == &wellPathToApply)
+    {
+        RimProject* proj = RiaApplication::instance()->project();
+
+        if (proj->activeOilField()->wellPathCollection())
+        {
+            for (RimWellPath* wellPath : proj->activeOilField()->wellPathCollection()->wellPaths)
+            {
+                optionList.push_back(caf::PdmOptionItemInfo(wellPath->name(), wellPath));
+            }
+        }
+    }
+
+    return optionList;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicChangeDataSourceFeatureUi::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
+{
+    caf::PdmUiGroup* group = uiOrdering.addNewGroup("Apply the following for all selected curves");
+
+    group->add(&caseToApply);
+    group->add(&wellPathToApply);
+}

ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeatureUi.h

@@ -0,0 +1,46 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016      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.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "cafPdmObject.h"
+#include "cafPdmPtrField.h"
+#include "cafPdmUiOrdering.h"
+
+class RimCase;
+class RimWellPath;
+
+
+//==================================================================================================
+/// 
+//==================================================================================================
+class RicChangeDataSourceFeatureUi : public caf::PdmObject
+{
+    CAF_PDM_HEADER_INIT;
+
+public:
+    RicChangeDataSourceFeatureUi();
+
+    caf::PdmPtrField<RimCase*>     caseToApply;
+    caf::PdmPtrField<RimWellPath*> wellPathToApply;
+
+protected:
+    virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;
+
+    virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
+};

ApplicationCode/Commands/WellLogCommands/RicWellLogPlotCurveFeatureImpl.cpp

@@ -19,6 +19,10 @@
 
 #include "RicWellLogPlotCurveFeatureImpl.h"
 
+#include "RimWellLogCurve.h"
+
+#include "cafSelectionManager.h"
+
 #include <QColor>
 
 static const int RI_LOGPLOT_CURVECOLORSCOUNT = 15;
@@ -52,3 +56,39 @@ cvf::Color3f RicWellLogPlotCurveFeatureImpl::curveColorFromTable()
     cvf::Color3f cvfColor(color.redF(), color.greenF(), color.blueF());
     return cvfColor;
 }
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<RimWellLogCurve*> RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves()
+{
+    std::set<RimWellLogCurve*> curveSet;
+
+    {
+        std::vector<caf::PdmUiItem*> selectedItems;
+        caf::SelectionManager::instance()->selectedItems(selectedItems);
+
+        for (caf::PdmUiItem* selectedItem : selectedItems)
+        {
+            caf::PdmObjectHandle* objHandle = dynamic_cast<caf::PdmObjectHandle*>(selectedItem);
+            if (objHandle)
+            {
+                std::vector<RimWellLogCurve*> childCurves;
+                objHandle->descendantsIncludingThisOfType(childCurves);
+
+                for (RimWellLogCurve* curve : childCurves)
+                {
+                    curveSet.insert(curve);
+                }
+            }
+        }
+    }
+
+    std::vector<RimWellLogCurve*> allCurves;
+    for (RimWellLogCurve* curve : curveSet)
+    {
+        allCurves.push_back(curve);
+    }
+
+    return allCurves;
+}

ApplicationCode/Commands/WellLogCommands/RicWellLogPlotCurveFeatureImpl.h

@@ -21,12 +21,14 @@
 
 #include "cafPdmFieldCvfColor.h"
 
+class RimWellLogCurve;
+
 //==================================================================================================
 /// 
 //==================================================================================================
 class RicWellLogPlotCurveFeatureImpl
 {
-
 public:
     static cvf::Color3f curveColorFromTable();
+    static std::vector<RimWellLogCurve*> selectedWellLogCurves();
 };

ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp

@@ -282,7 +282,7 @@ bool RifEclipseInputFileTools::readDataFromKeyword(ecl_kw_type* eclipseKeywordDa
 
     bool mathingItemCount = false;
     {
-        int itemCount = ecl_kw_get_size(eclipseKeywordData);
+        size_t itemCount = static_cast<size_t>(ecl_kw_get_size(eclipseKeywordData));
         if (itemCount == caseData->mainGrid()->cellCount())
         {
             mathingItemCount = true;
@@ -488,7 +488,7 @@ bool RifEclipseInputFileTools::writeBinaryResultToTextFile(const QString& fileNa
         return false;
     }
 
-    cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, eclipseCase->mainGrid()->gridIndex(), porosityModel, timeStep, resultName);
+    cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, eclipseCase->mainGrid()->gridIndex(), porosityModel, timeStep, resultName);
     if (resultAccessor.isNull())
     {
         return false;

ApplicationCode/GeoMech/GeoMechDataModel/RigFemPart.cpp

@@ -287,16 +287,13 @@ float RigFemPart::characteristicElementSize()
 {
     if (m_characteristicElementSize != std::numeric_limits<float>::infinity()) return m_characteristicElementSize;
 
-    // take 100 elements 
-    float elmIdxJump = elementCount() / 100.0f;
-    int elmIdxIncrement = elmIdxJump < 1 ? 1: (int) elmIdxJump;
     int elmsToAverageCount = 0;
     float sumMaxEdgeLength = 0;
-    for (int elmIdx = 0; elmIdx < elementCount(); elmIdx += elmIdxIncrement)
+    for (int elmIdx = 0; elmIdx < elementCount(); elmIdx++)
     {
         RigElementType eType = this->elementType(elmIdx);
 
-        if (eType == HEX8 || eType == HEX8P)
+        if (eType == HEX8P)
         {
             const int* elmentConn = this->connectivities(elmIdx);
             cvf::Vec3f nodePos0 = this->nodes().coordinates[elmentConn[0]];

ApplicationCode/GeoMech/GeoMechDataModel/RigFemResultAddress.h

@@ -51,9 +51,9 @@ public:
     }
 
     RigFemResultPosEnum resultPosType;
-    std::string fieldName;
-    std::string componentName;
-    int         timeLapseBaseFrameIdx;
+    std::string         fieldName;
+    std::string         componentName;
+    int                 timeLapseBaseFrameIdx;
 
     static const int ALL_TIME_LAPSES = -2;
 

ApplicationCode/GeoMech/GeoMechDataModel/RigFemScalarResultFrames.h

@@ -20,12 +20,10 @@
 #pragma once
 #include "cvfObject.h"
 #include <vector>
-#include <string>
 
 //==================================================================================================
 /// 
 //==================================================================================================
-class RigStatisticsDataCache;
 
 class RigFemScalarResultFrames: public cvf::Object
 {
@@ -33,11 +31,11 @@ public:
     RigFemScalarResultFrames(int frameCount);
     virtual ~RigFemScalarResultFrames();
 
-    void enableAsSingleFrameResult();
+    void                      enableAsSingleFrameResult();
 
-    std::vector<float>& frameData(size_t frameIndex);
+    std::vector<float>&       frameData(size_t frameIndex);
     const std::vector<float>& frameData(size_t frameIndex) const;
-    int frameCount() const;
+    int                       frameCount() const;
 
 private:
     std::vector< std::vector<float> > m_dataForEachFrame;

ApplicationCode/ModelVisualization/Intersections/RivIntersectionBoxPartMgr.cpp

@@ -126,10 +126,10 @@ void RivIntersectionBoxPartMgr::updateCellResultColor(size_t timeStepIndex)
                 }
                 else
                 {
-                    resultAccessor = RigResultAccessorFactory::createResultAccessor(cellResultColors->reservoirView()->eclipseCase()->reservoirData(),
-                                                                                    0,
-                                                                                    timeStepIndex,
-                                                                                    cellResultColors);
+                    resultAccessor = RigResultAccessorFactory::createFromResultDefinition(cellResultColors->reservoirView()->eclipseCase()->reservoirData(),
+                                                                                          0,
+                                                                                          timeStepIndex,
+                                                                                          cellResultColors);
                 }
 
                 RivIntersectionPartMgr::calculateEclipseTextureCoordinates(m_intersectionBoxFacesTextureCoords.p(),

ApplicationCode/ModelVisualization/Intersections/RivIntersectionPartMgr.cpp

@@ -130,10 +130,10 @@ void RivIntersectionPartMgr::updateCellResultColor(size_t timeStepIndex)
                 }
                 else
                 {
-                    resultAccessor = RigResultAccessorFactory::createResultAccessor(cellResultColors->reservoirView()->eclipseCase()->reservoirData(),
-                                                                                    0,
-                                                                                    timeStepIndex,
-                                                                                    cellResultColors);
+                    resultAccessor = RigResultAccessorFactory::createFromResultDefinition(cellResultColors->reservoirView()->eclipseCase()->reservoirData(),
+                                                                                          0,
+                                                                                          timeStepIndex,
+                                                                                          cellResultColors);
                 }
 
                 RivIntersectionPartMgr::calculateEclipseTextureCoordinates(m_crossSectionFacesTextureCoords.p(),

ApplicationCode/ModelVisualization/RivCellEdgeGeometryUtils.cpp

@@ -315,7 +315,7 @@ cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellEdgeResultAccess
                 adjustedTimeStep = 0;
             }
 
-            cvf::ref<RigResultAccessor> daObj = RigResultAccessorFactory::createResultAccessor(eclipseCase, grid->gridIndex(), porosityModel, adjustedTimeStep, resultIndices[cubeFaceIdx]);
+            cvf::ref<RigResultAccessor> daObj = RigResultAccessorFactory::createFromResultIdx(eclipseCase, grid->gridIndex(), porosityModel, adjustedTimeStep, resultIndices[cubeFaceIdx]);
             cellEdgeResultAccessor->setDataAccessObjectForFace(static_cast<cvf::StructGridInterface::FaceType>(cubeFaceIdx), daObj.p());
         }
     }
@@ -332,14 +332,7 @@ cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellCenterResultAcce
 
     if (cellResultColors->hasResult())
     {
-        if (!cellResultColors->hasDynamicResult())
-        {
-            // Static result values are located at time step 0
-            timeStepIndex = 0;
-        }
-
-        RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(cellResultColors->porosityModel());
-        resultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, grid->gridIndex(), porosityModel, timeStepIndex, cellResultColors->resultVariable());
+        resultAccessor = RigResultAccessorFactory::createFromResultDefinition(eclipseCase, grid->gridIndex(), timeStepIndex, cellResultColors);
     }
 
     if (resultAccessor.isNull())

ApplicationCode/ModelVisualization/RivGridPartMgr.cpp

@@ -234,21 +234,26 @@ void RivGridPartMgr::updateCellResultColor(size_t timeStepIndex, RimEclipseCellC
         if (cellResultColors->isTernarySaturationSelected())
         {
             RivTernaryTextureCoordsCreator texturer(cellResultColors, cellResultColors->ternaryLegendConfig(),
-                timeStepIndex,
-                m_grid->gridIndex(),
-                m_surfaceGenerator.quadToCellFaceMapper());
+                                                    timeStepIndex,
+                                                    m_grid->gridIndex(),
+                                                    m_surfaceGenerator.quadToCellFaceMapper());
 
             texturer.createTextureCoords(m_surfaceFacesTextureCoords.p());
 
             const RivTernaryScalarMapper* mapper = cellResultColors->ternaryLegendConfig()->scalarMapper();
-            RivScalarMapperUtils::applyTernaryTextureResultsToPart(m_surfaceFaces.p(), m_surfaceFacesTextureCoords.p(), mapper, m_opacityLevel, caf::FC_NONE, cellResultColors->reservoirView()->isLightingDisabled());
+            RivScalarMapperUtils::applyTernaryTextureResultsToPart(m_surfaceFaces.p(), 
+                                                                   m_surfaceFacesTextureCoords.p(), 
+                                                                   mapper, 
+                                                                   m_opacityLevel, 
+                                                                   caf::FC_NONE, 
+                                                                   cellResultColors->reservoirView()->isLightingDisabled());
         }
         else
         {
             RivTextureCoordsCreator texturer(cellResultColors,
-                timeStepIndex,
-                m_grid->gridIndex(),
-                m_surfaceGenerator.quadToCellFaceMapper());
+                                             timeStepIndex,
+                                             m_grid->gridIndex(),
+                                             m_surfaceGenerator.quadToCellFaceMapper());
             if (!texturer.isValid())
             {
                 return;
@@ -257,7 +262,12 @@ void RivGridPartMgr::updateCellResultColor(size_t timeStepIndex, RimEclipseCellC
             texturer.createTextureCoords(m_surfaceFacesTextureCoords.p());
 
             const cvf::ScalarMapper* mapper = cellResultColors->legendConfig()->scalarMapper();
-            RivScalarMapperUtils::applyTextureResultsToPart(m_surfaceFaces.p(), m_surfaceFacesTextureCoords.p(), mapper, m_opacityLevel, caf::FC_NONE, cellResultColors->reservoirView()->isLightingDisabled());
+            RivScalarMapperUtils::applyTextureResultsToPart(m_surfaceFaces.p(), 
+                                                            m_surfaceFacesTextureCoords.p(), 
+                                                            mapper, 
+                                                            m_opacityLevel, 
+                                                            caf::FC_NONE, 
+                                                            cellResultColors->reservoirView()->isLightingDisabled());
         }
     }
 }

ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.cpp

@@ -789,16 +789,7 @@ void RivReservoirViewPartMgr::computePropertyVisibility(cvf::UByteArray* cellVis
 
                 RigCaseData* eclipseCase = propFilterColl->reservoirView()->eclipseCase()->reservoirData();
 
-                size_t adjustedTimeStepIndex = timeStepIndex;
-
-                // Set time step to zero for static results
-                if (propertyFilter->resultDefinition()->hasStaticResult())
-                {
-                    adjustedTimeStepIndex = 0;
-                }
-
-                RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(propertyFilter->resultDefinition()->porosityModel());
-                cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, grid->gridIndex(), porosityModel, adjustedTimeStepIndex, propertyFilter->resultDefinition->resultVariable(), propertyFilter->resultDefinition->resultType());
+                cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromResultDefinition(eclipseCase, grid->gridIndex(),  timeStepIndex, propertyFilter->resultDefinition);
 
                 CVF_ASSERT(resultAccessor.notNull());
 

ApplicationCode/ModelVisualization/RivTernaryTextureCoordsCreator.cpp

@@ -55,9 +55,9 @@ RivTernaryTextureCoordsCreator::RivTernaryTextureCoordsCreator(
 
     RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(cellResultColors->porosityModel());
 
-    cvf::ref<RigResultAccessor> soil = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SOIL");
-    cvf::ref<RigResultAccessor> sgas = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SGAS");
-    cvf::ref<RigResultAccessor> swat = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SWAT");
+    cvf::ref<RigResultAccessor> soil = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SOIL");
+    cvf::ref<RigResultAccessor> sgas = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SGAS");
+    cvf::ref<RigResultAccessor> swat = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SWAT");
 
     m_resultAccessor = new RigTernaryResultAccessor();
     m_resultAccessor->setTernaryResultAccessors(soil.p(), sgas.p(), swat.p());
@@ -90,9 +90,9 @@ RivTernaryTextureCoordsCreator::RivTernaryTextureCoordsCreator(
     RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(cellResultColors->porosityModel());
 
     size_t gridIndex = 0;
-    cvf::ref<RigResultAccessor> soil = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SOIL");
-    cvf::ref<RigResultAccessor> sgas = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SGAS");
-    cvf::ref<RigResultAccessor> swat = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SWAT");
+    cvf::ref<RigResultAccessor> soil = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SOIL");
+    cvf::ref<RigResultAccessor> sgas = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SGAS");
+    cvf::ref<RigResultAccessor> swat = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, resTimeStepIdx, "SWAT");
 
     m_resultAccessor = new RigTernaryResultAccessor();
     m_resultAccessor->setTernaryResultAccessors(soil.p(), sgas.p(), swat.p());

ApplicationCode/ModelVisualization/RivTextureCoordsCreator.cpp

@@ -43,7 +43,7 @@ RivTextureCoordsCreator::RivTextureCoordsCreator(RimEclipseCellColors* cellResul
     m_quadMapper = quadMapper;
     CVF_ASSERT(quadMapper && eclipseCase );
 
-    m_resultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, timeStepIndex, cellResultColors);
+    m_resultAccessor = RigResultAccessorFactory::createFromResultDefinition(eclipseCase, gridIndex, timeStepIndex, cellResultColors);
 
     cvf::ref<RigPipeInCellEvaluator> pipeInCellEval = 
         new RigPipeInCellEvaluator(cellResultColors->reservoirView()->wellCollection()->resultWellGeometryVisibilities(timeStepIndex),
@@ -79,11 +79,10 @@ void RivTextureCoordsCreator::createTextureCoords(cvf::Vec2fArray* quadTextureCo
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RivTextureCoordsCreator::createTextureCoords(
-    cvf::Vec2fArray* quadTextureCoords,
-    const cvf::StructGridQuadToCellFaceMapper* quadMapper,
-    const RigResultAccessor* resultAccessor,
-    const RivResultToTextureMapper* texMapper)
+void RivTextureCoordsCreator::createTextureCoords(cvf::Vec2fArray* quadTextureCoords,
+                                                  const cvf::StructGridQuadToCellFaceMapper* quadMapper,
+                                                  const RigResultAccessor* resultAccessor,
+                                                  const RivResultToTextureMapper* texMapper)
 {
     CVF_ASSERT(quadTextureCoords && quadMapper && resultAccessor && texMapper);
 

ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp

@@ -208,6 +208,9 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
         if (isResultsInfoRelevant)
         {
             size_t scalarIndex = eclipseView->cellResult()->scalarResultIndex();
+            if (scalarIndex != cvf::UNDEFINED_SIZE_T)
+            {
+
             if (m_statisticsCellRange == ALL_CELLS)
             {
                 if (m_statisticsTimeRange == ALL_TIMESTEPS)
@@ -256,6 +259,7 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
                     histogram = &(m_visibleCellStatistics->cellScalarValuesHistogram(currentTimeStep));
                 }
             }
+            }
         }
     }
 
@@ -364,7 +368,7 @@ void Rim3dOverlayInfoConfig::updateEclipse3DInfo(RimEclipseView * eclipseView)
 
     if (showHistogram())
     {
-        if (isResultsInfoRelevant)
+        if (isResultsInfoRelevant && histogram)
         {
             eclipseView->viewer()->showHistogram(true);
             eclipseView->viewer()->setHistogram(min, max, *histogram);

ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp

@@ -409,6 +409,7 @@ QStringList RimContextCommandBuilder::commandsFromSelection()
         {
             commandIds << "RicCopyReferencesToClipboardFeature";
             commandIds << "RicExportToLasFileFeature";
+            commandIds << "RicChangeDataSourceFeature";
         }
         else if (dynamic_cast<RimWellLogPlotCollection*>(uiItem))
         {

ApplicationCode/ProjectDataModel/RimEclipsePropertyFilter.cpp

@@ -37,6 +37,8 @@
 
 #include "cvfAssert.h"
 #include "cvfMath.h"
+#include "RigFlowDiagResults.h"
+#include "RimFlowDiagSolution.h"
 
 
 namespace caf
@@ -292,32 +294,53 @@ void RimEclipsePropertyFilter::computeResultValueRange()
 
     clearCategories();
 
-    size_t scalarIndex = resultDefinition->scalarResultIndex();
-    if (scalarIndex != cvf::UNDEFINED_SIZE_T)
+    if (resultDefinition->resultType() == RimDefines::FLOW_DIAGNOSTICS)
     {
-        RimReservoirCellResultsStorage* results = resultDefinition->currentGridCellResults();
-        if (results)
+        RimView* view;
+        this->firstAncestorOrThisOfType(view);
+
+        int timeStep = 0;
+        if (view) timeStep = view->currentTimeStep();
+        RigFlowDiagResultAddress resAddr = resultDefinition->flowDiagResAddress();
+        if ( resultDefinition->flowDiagSolution() )
         {
-            results->cellResults()->minMaxCellScalarValues(scalarIndex, min, max);
+            RigFlowDiagResults* results = resultDefinition->flowDiagSolution()->flowDiagResults();
+            results->minMaxScalarValues(resAddr, timeStep, &max, &max);
 
-            if (resultDefinition->hasCategoryResult())
+            if ( resultDefinition->hasCategoryResult() )
             {
-                if (resultDefinition->resultType() != RimDefines::FORMATION_NAMES)
-                {
-                    setCategoryValues(results->cellResults()->uniqueCellScalarValues(scalarIndex));
-                }
-                else
-                {
-                    CVF_ASSERT(parentContainer()->reservoirView()->eclipseCase()->reservoirData());
-                    CVF_ASSERT(parentContainer()->reservoirView()->eclipseCase()->reservoirData()->activeFormationNames());
+                setCategoryValues(results->uniqueCellScalarValues(resAddr, timeStep));
+            }
+        }
+    }
+    else
+    {
+        size_t scalarIndex = resultDefinition->scalarResultIndex();
+        if ( scalarIndex != cvf::UNDEFINED_SIZE_T )
+        {
+            RimReservoirCellResultsStorage* results = resultDefinition->currentGridCellResults();
+            if ( results )
+            {
+                results->cellResults()->minMaxCellScalarValues(scalarIndex, min, max);
 
-                    const std::vector<QString>& fnVector = parentContainer()->reservoirView()->eclipseCase()->reservoirData()->activeFormationNames()->formationNames();
-                    setCategoryNames(fnVector);
+                if ( resultDefinition->hasCategoryResult() )
+                {
+                    if ( resultDefinition->resultType() != RimDefines::FORMATION_NAMES )
+                    {
+                        setCategoryValues(results->cellResults()->uniqueCellScalarValues(scalarIndex));
+                    }
+                    else
+                    {
+                        CVF_ASSERT(parentContainer()->reservoirView()->eclipseCase()->reservoirData());
+                        CVF_ASSERT(parentContainer()->reservoirView()->eclipseCase()->reservoirData()->activeFormationNames());
+
+                        const std::vector<QString>& fnVector = parentContainer()->reservoirView()->eclipseCase()->reservoirData()->activeFormationNames()->formationNames();
+                        setCategoryNames(fnVector);
+                    }
                 }
             }
         }
     }
-
     m_maximumResultValue = max;
     m_minimumResultValue = min;
 

ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp

@@ -35,6 +35,7 @@
 #include "RimReservoirCellResultsStorage.h"
 #include "RimTools.h"
 #include "RimFlowDiagSolution.h"
+#include "RigFlowDiagSolverInterface.h"
 
 #include "cafPdmSettings.h"
 #include "cafPdmUiPropertyViewDialog.h"
@@ -71,6 +72,8 @@ RimEclipseResultCase::RimEclipseResultCase()
     flipYAxis.xmlCapability()->setIOWritable(true);
     //flipYAxis.uiCapability()->setUiHidden(true);
 
+    m_flowDagSolverInterface = new RigFlowDiagSolverInterface(this);
+
     m_activeCellInfoIsReadFromFile = false;
     m_gridAndWellDataIsReadFromFile = false;
 }
@@ -357,6 +360,14 @@ std::vector<RimFlowDiagSolution*> RimEclipseResultCase::flowDiagSolutions()
     return flowSols;
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagSolverInterface* RimEclipseResultCase::flowDiagSolverInterface()
+{
+    return m_flowDagSolverInterface.p();
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/RimEclipseResultCase.h

@@ -25,6 +25,7 @@
 class RifReaderInterface;
 class RigMainGrid;
 class RimFlowDiagSolution;
+class RigFlowDiagSolverInterface;
 
 //==================================================================================================
 //
@@ -52,6 +53,8 @@ public:
     virtual void                updateFilePathsFromProjectPath(const QString& newProjectPath, const QString& oldProjectPath);
 
     std::vector<RimFlowDiagSolution*> flowDiagSolutions();
+    RigFlowDiagSolverInterface*       flowDiagSolverInterface();
+
 private:
     cvf::ref<RifReaderInterface> createMockModel(QString modelName);
 
@@ -59,6 +62,8 @@ private:
 
     virtual void                defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering );
 
+    cvf::ref<RigFlowDiagSolverInterface>        m_flowDagSolverInterface;
+
     // Fields:                        
     caf::PdmField<QString>      caseFileName;
     caf::PdmChildArrayField<RimFlowDiagSolution*> m_flowDiagSolutions;

ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp

@@ -38,6 +38,8 @@
 #include "cafPdmUiListEditor.h"
 #include "RimEclipseResultCase.h"
 
+#include "RigFlowDiagResultAddress.h"
+
 CAF_PDM_SOURCE_INIT(RimEclipseResultDefinition, "ResultDefinition");
 
 //--------------------------------------------------------------------------------------------------
@@ -96,6 +98,18 @@ RimEclipseResultDefinition::~RimEclipseResultDefinition()
 }
 
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RimEclipseResultDefinition::simpleCopy(const RimEclipseResultDefinition* other)
+{
+    this->setResultVariable(other->resultVariable());
+    this->setPorosityModel(other->porosityModel());
+    this->setResultType(other->resultType());
+    this->setFlowSolution(other->m_flowSolution());
+    this->setSelectedTracers(other->m_selectedTracers());
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -122,23 +136,35 @@ RimReservoirCellResultsStorage* RimEclipseResultDefinition::currentGridCellResul
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
 {
-    if (   &m_resultTypeUiField == changedField 
+    if (   &m_flowSolutionUiField  == changedField 
+        || &m_resultTypeUiField    == changedField
         || &m_porosityModelUiField == changedField )
     {
+        // If the user are seeing the list with the actually selected result, 
+        // select that result in the list. Otherwise select nothing.
+
         QStringList varList = getResultNamesForCurrentUiResultType();
 
-        // If the user are seeing the list with the actually selected result, select that result in the list. Otherwise select nothing.
-        if (   m_resultTypeUiField() == m_resultType() 
-            && m_porosityModelUiField() == m_porosityModel() 
-            && varList.contains(resultVariable()))
+        bool isFlowDiagFieldsRelevant = (m_resultType() == RimDefines::FLOW_DIAGNOSTICS);
+        
+
+        if (   ( m_flowSolutionUiField() == m_flowSolution() || !isFlowDiagFieldsRelevant)
+            &&  m_resultTypeUiField()    == m_resultType()
+            &&  m_porosityModelUiField() == m_porosityModel() )
         {
-            m_resultVariableUiField = resultVariable();
+            if (varList.contains(resultVariable()))
+            {
+                m_resultVariableUiField = resultVariable();
+            }
+
+            if (isFlowDiagFieldsRelevant) m_selectedTracersUiField = m_selectedTracers();
+            else                          m_selectedTracersUiField = std::vector<QString>();
         }
         else
         {
             m_resultVariableUiField = "";
+            m_selectedTracersUiField = std::vector<QString>();
         }
-
     }
 
     if (&m_resultVariableUiField == changedField)
@@ -285,10 +311,10 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calculateValueOptions(
     {
         if ( fieldNeedingOptions == &m_resultVariableUiField )
         {
-            optionItems.push_back(caf::PdmOptionItemInfo("Time Of Flight (Weighted Sum)",   "TOF"));
-            optionItems.push_back(caf::PdmOptionItemInfo("Tracer Concentration (Sum)",      "Concentrations"));
-            optionItems.push_back(caf::PdmOptionItemInfo("Tracer with Max Concentration",   "MaxTracer"));
-            optionItems.push_back(caf::PdmOptionItemInfo("Injector Producer Communication", "Communication"));
+            optionItems.push_back(caf::PdmOptionItemInfo("Time Of Flight (Weighted Sum)",   RIG_FLD_TOF_RESNAME));
+            optionItems.push_back(caf::PdmOptionItemInfo("Tracer Cell Fraction (Sum)",      RIG_FLD_CELL_FRACTION_RESNAME));
+            optionItems.push_back(caf::PdmOptionItemInfo("Max Fraction Tracer",             RIG_FLD_MAX_FRACTION_TRACER_RESNAME));
+            optionItems.push_back(caf::PdmOptionItemInfo("Injector Producer Communication", RIG_FLD_COMMUNICATION_RESNAME));
         }
         else if (fieldNeedingOptions == &m_flowSolutionUiField)
         {
@@ -446,13 +472,11 @@ QStringList RimEclipseResultDefinition::getResultNamesForCurrentUiResultType()
     }
     else
     {
-        // TODO: Get this form some sensible place
-
         QStringList flowVars;
-        flowVars.push_back("TOF");
-        flowVars.push_back("Concentrations");
-        flowVars.push_back("MaxTracer");
-        flowVars.push_back("Communication");
+        flowVars.push_back(RIG_FLD_TOF_RESNAME);
+        flowVars.push_back(RIG_FLD_CELL_FRACTION_RESNAME);
+        flowVars.push_back(RIG_FLD_MAX_FRACTION_TRACER_RESNAME);
+        flowVars.push_back(RIG_FLD_COMMUNICATION_RESNAME);
         return flowVars;
     }
 }
@@ -464,6 +488,8 @@ size_t RimEclipseResultDefinition::scalarResultIndex() const
 {
     size_t gridScalarResultIndex = cvf::UNDEFINED_SIZE_T;
 
+    if (m_resultType() == RimDefines::FLOW_DIAGNOSTICS) return cvf::UNDEFINED_SIZE_T;
+
     const RimReservoirCellResultsStorage* gridCellResults = this->currentGridCellResults();
     if (gridCellResults && gridCellResults->cellResults())
     {
@@ -473,11 +499,29 @@ size_t RimEclipseResultDefinition::scalarResultIndex() const
     return gridScalarResultIndex;
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagResultAddress RimEclipseResultDefinition::flowDiagResAddress() const
+{
+    CVF_ASSERT(m_resultType() == RimDefines::FLOW_DIAGNOSTICS);
+
+    std::set<std::string> selTracerNames;
+    for (const QString& tName : m_selectedTracers())
+    {
+        selTracerNames.insert(tName.toStdString());
+    }
+
+    return RigFlowDiagResultAddress(m_resultVariable().toStdString(), selTracerNames);
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::loadResult()
 {
+    if (m_resultType() == RimDefines::FLOW_DIAGNOSTICS) return; // Will load automatically on access
+
     RimReservoirCellResultsStorage* gridCellResults = this->currentGridCellResults();
     if (gridCellResults)
     {
@@ -492,6 +536,8 @@ void RimEclipseResultDefinition::loadResult()
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseResultDefinition::hasStaticResult() const
 {
+    if (this->resultType() == RimDefines::FLOW_DIAGNOSTICS) return false;
+
     const RimReservoirCellResultsStorage* gridCellResults = this->currentGridCellResults();
     size_t gridScalarResultIndex = this->scalarResultIndex();
 
@@ -510,7 +556,11 @@ bool RimEclipseResultDefinition::hasStaticResult() const
 //--------------------------------------------------------------------------------------------------
 bool RimEclipseResultDefinition::hasResult() const
 {
-    if (this->currentGridCellResults() && this->currentGridCellResults()->cellResults())
+    if (this->resultType() == RimDefines::FLOW_DIAGNOSTICS)
+    {
+        if (m_flowSolution() && !m_resultVariable().isEmpty()) return true;
+    }
+    else if (this->currentGridCellResults() && this->currentGridCellResults()->cellResults())
     {
         const RigCaseCellResultsData* gridCellResults = this->currentGridCellResults()->cellResults();
         size_t gridScalarResultIndex = gridCellResults->findScalarResultIndex(m_resultType(), m_resultVariable());
@@ -532,6 +582,10 @@ bool RimEclipseResultDefinition::hasDynamicResult() const
         {
             return true;
         }
+        else if (m_resultType() == RimDefines::FLOW_DIAGNOSTICS)
+        {
+            return true;
+        }
 
         if (this->currentGridCellResults() && this->currentGridCellResults()->cellResults())
         {
@@ -590,6 +644,32 @@ void RimEclipseResultDefinition::setResultVariable(const QString& val)
     m_resultVariableUiField = val;
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RimFlowDiagSolution* RimEclipseResultDefinition::flowDiagSolution()
+{
+    return m_flowSolution();
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RimEclipseResultDefinition::setFlowSolution(RimFlowDiagSolution* flowSol)
+{
+    this->m_flowSolution = flowSol;
+    this->m_flowSolutionUiField = flowSol;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RimEclipseResultDefinition::setSelectedTracers(const std::vector<QString>& selectedTracers)
+{
+    this->m_selectedTracers = selectedTracers;
+    this->m_selectedTracersUiField = selectedTracers;
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -611,6 +691,9 @@ bool RimEclipseResultDefinition::hasCategoryResult() const
         && m_eclipseCase->reservoirData() 
         && m_eclipseCase->reservoirData()->activeFormationNames() ) return true;
 
+    if (this->m_resultType() == RimDefines::FLOW_DIAGNOSTICS
+        && m_resultVariable() == RIG_FLD_MAX_FRACTION_TRACER_RESNAME) return true;
+
     if (!this->hasStaticResult()) return false;
 
     return this->resultVariable().contains("NUM", Qt::CaseInsensitive);
@@ -648,6 +731,17 @@ void RimEclipseResultDefinition::defineUiOrdering(QString uiConfigName, caf::Pdm
     { 
         uiOrdering.add(&m_flowSolutionUiField);
         uiOrdering.add(&m_selectedTracersUiField);
+
+        if ( m_flowSolution() == nullptr )
+        {
+            RimEclipseResultCase* eclCase;
+            this->firstAncestorOrThisOfType(eclCase);
+            if ( eclCase )
+            {
+                std::vector<RimFlowDiagSolution*> flowSols = eclCase->flowDiagSolutions();
+                if (flowSols.size()){ this->setFlowSolution(flowSols[0]); } 
+            }
+        }
     }
     uiOrdering.add(&m_resultVariableUiField);
 

ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.h

@@ -27,6 +27,7 @@
 #include "cafPdmObject.h"
 #include "cafPdmPointer.h"
 #include "cafPdmPtrField.h"
+#include "RigFlowDiagResultAddress.h"
 
 class RigCaseCellResultsData;
 class RimEclipseCase;
@@ -45,6 +46,8 @@ public:
     RimEclipseResultDefinition();
     virtual ~RimEclipseResultDefinition();
 
+    void                            simpleCopy(const RimEclipseResultDefinition* other);
+
     void                            setEclipseCase(RimEclipseCase* eclipseCase);
 
     RimDefines::ResultCatType       resultType() const { return m_resultType(); }
@@ -53,6 +56,8 @@ public:
     void                            setPorosityModel(RimDefines::PorosityModelType val);
     QString                         resultVariable() const { return m_resultVariable(); }
     virtual void                    setResultVariable(const QString& val);
+    RimFlowDiagSolution*            flowDiagSolution();
+    RigFlowDiagResultAddress        flowDiagResAddress() const;
 
     void                            loadResult();
     size_t                          scalarResultIndex() const;
@@ -100,7 +105,10 @@ protected:
     caf::PdmPointer<RimEclipseCase>                                 m_eclipseCase;
 
 private:
-    bool                            hasDualPorFractureResult(); 
+    void                            setFlowSolution(RimFlowDiagSolution* flowSol);
+    void                            setSelectedTracers(const std::vector<QString>& selectedTracers);
+
+    bool                            hasDualPorFractureResult();
 
     QList<caf::PdmOptionItemInfo>   calcOptionsForVariableUiFieldStandard();
     QStringList                     getResultNamesForCurrentUiResultType();

ApplicationCode/ProjectDataModel/RimEclipseStatisticsCaseEvaluator.cpp

@@ -161,7 +161,7 @@ void RimEclipseStatisticsCaseEvaluator::evaluateForResults(const QList<ResSpec>&
                     // Trigger loading of dataset
                     sourceCase->results(poroModel)->findOrLoadScalarResultForTimeStep(resultType, resultName, dataAccessTimeStepIndex);
 
-                    cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createResultAccessor(sourceCase->reservoirData(), gridIdx, poroModel, dataAccessTimeStepIndex, resultName, resultType);
+                    cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromNameAndType(sourceCase->reservoirData(), gridIdx, poroModel, dataAccessTimeStepIndex, resultName, resultType);
                     if (resultAccessor.notNull())
                     {
                         sourceDataAccessList.push_back(resultAccessor.p());

ApplicationCode/ProjectDataModel/RimEclipseView.cpp

@@ -76,6 +76,9 @@
 #include <QMessageBox>
 
 #include <limits.h>
+#include "RimEclipseResultDefinition.h"
+#include "RimFlowDiagSolution.h"
+#include "RigFlowDiagResults.h"
 
 
 
@@ -947,6 +950,7 @@ void RimEclipseView::updateLegends()
     CVF_ASSERT(results);
 
     updateMinMaxValuesAndAddLegendToView(QString("Cell Results: \n"), this->cellResult(), results);
+
     if (this->faultResultSettings()->showCustomFaultResult() && this->faultResultSettings()->hasValidCustomResult())
     {
         updateMinMaxValuesAndAddLegendToView(QString("Fault Results: \n"), this->currentFaultResultColors(), results);
@@ -992,47 +996,90 @@ void RimEclipseView::updateMinMaxValuesAndAddLegendToView(QString legendLabel, R
 {
     if (resultColors->hasResult())
     {
-        double globalMin, globalMax;
-        double globalPosClosestToZero, globalNegClosestToZero;
-        cellResultsData->minMaxCellScalarValues(resultColors->scalarResultIndex(), globalMin, globalMax);
-        cellResultsData->posNegClosestToZero(resultColors->scalarResultIndex(), globalPosClosestToZero, globalNegClosestToZero);
-
-        double localMin, localMax;
-        double localPosClosestToZero, localNegClosestToZero;
-        if (resultColors->hasDynamicResult())
+        if (resultColors->resultType() == RimDefines::FLOW_DIAGNOSTICS)
         {
-            cellResultsData->minMaxCellScalarValues(resultColors->scalarResultIndex(), m_currentTimeStep, localMin, localMax);
-            cellResultsData->posNegClosestToZero(resultColors->scalarResultIndex(), m_currentTimeStep, localPosClosestToZero, localNegClosestToZero);
-        }
-        else
-        {
-            localMin = globalMin;
-            localMax = globalMax;
+            double globalMin, globalMax;
+            double globalPosClosestToZero, globalNegClosestToZero;
+            RigFlowDiagResults* cellResultsData = resultColors->flowDiagSolution()->flowDiagResults();
+            RigFlowDiagResultAddress resAddr = resultColors->flowDiagResAddress();
 
-            localPosClosestToZero = globalPosClosestToZero;
-            localNegClosestToZero = globalNegClosestToZero;
-        }
+            cellResultsData->minMaxScalarValues(resAddr, m_currentTimeStep, &globalMin, &globalMax);
+            cellResultsData->posNegClosestToZero(resAddr, m_currentTimeStep, &globalPosClosestToZero, &globalNegClosestToZero);
 
-        CVF_ASSERT(resultColors->legendConfig());
-
-        resultColors->legendConfig()->setClosestToZeroValues(globalPosClosestToZero, globalNegClosestToZero, localPosClosestToZero, localNegClosestToZero);
-        resultColors->legendConfig()->setAutomaticRanges(globalMin, globalMax, localMin, localMax);
-
-        if (resultColors->hasCategoryResult())
-        {
-            if(resultColors->resultType() != RimDefines::FORMATION_NAMES)
+            double localMin, localMax;
+            double localPosClosestToZero, localNegClosestToZero;
+            if ( resultColors->hasDynamicResult() )
             {
-                resultColors->legendConfig()->setIntegerCategories(cellResultsData->uniqueCellScalarValues(resultColors->scalarResultIndex()));
+                cellResultsData->minMaxScalarValues(resAddr, m_currentTimeStep, &localMin, &localMax);
+                cellResultsData->posNegClosestToZero(resAddr, m_currentTimeStep, &localPosClosestToZero, &localNegClosestToZero);
             }
             else
             {
-                const std::vector<QString>& fnVector = eclipseCase()->reservoirData()->activeFormationNames()->formationNames();
-                resultColors->legendConfig()->setNamedCategoriesInverse(fnVector);
-            }
-        }
+                localMin = globalMin;
+                localMax = globalMax;
 
-        m_viewer->addColorLegendToBottomLeftCorner(resultColors->legendConfig()->legend());
-        resultColors->legendConfig()->setTitle(cvfqt::Utils::toString(legendLabel + resultColors->resultVariable()));
+                localPosClosestToZero = globalPosClosestToZero;
+                localNegClosestToZero = globalNegClosestToZero;
+            }
+
+            CVF_ASSERT(resultColors->legendConfig());
+
+            resultColors->legendConfig()->setClosestToZeroValues(globalPosClosestToZero, globalNegClosestToZero, localPosClosestToZero, localNegClosestToZero);
+            resultColors->legendConfig()->setAutomaticRanges(globalMin, globalMax, localMin, localMax);
+
+            if ( resultColors->hasCategoryResult() )
+            {
+                resultColors->legendConfig()->setIntegerCategories(cellResultsData->uniqueCellScalarValues(resAddr, m_currentTimeStep));
+            }
+
+            m_viewer->addColorLegendToBottomLeftCorner(resultColors->legendConfig()->legend());
+            resultColors->legendConfig()->setTitle(cvfqt::Utils::toString(legendLabel + resultColors->resultVariable()));
+        
+        }
+        else
+        {
+            double globalMin, globalMax;
+            double globalPosClosestToZero, globalNegClosestToZero;
+            cellResultsData->minMaxCellScalarValues(resultColors->scalarResultIndex(), globalMin, globalMax);
+            cellResultsData->posNegClosestToZero(resultColors->scalarResultIndex(), globalPosClosestToZero, globalNegClosestToZero);
+
+            double localMin, localMax;
+            double localPosClosestToZero, localNegClosestToZero;
+            if ( resultColors->hasDynamicResult() )
+            {
+                cellResultsData->minMaxCellScalarValues(resultColors->scalarResultIndex(), m_currentTimeStep, localMin, localMax);
+                cellResultsData->posNegClosestToZero(resultColors->scalarResultIndex(), m_currentTimeStep, localPosClosestToZero, localNegClosestToZero);
+            }
+            else
+            {
+                localMin = globalMin;
+                localMax = globalMax;
+
+                localPosClosestToZero = globalPosClosestToZero;
+                localNegClosestToZero = globalNegClosestToZero;
+            }
+
+            CVF_ASSERT(resultColors->legendConfig());
+
+            resultColors->legendConfig()->setClosestToZeroValues(globalPosClosestToZero, globalNegClosestToZero, localPosClosestToZero, localNegClosestToZero);
+            resultColors->legendConfig()->setAutomaticRanges(globalMin, globalMax, localMin, localMax);
+
+            if ( resultColors->hasCategoryResult() )
+            {
+                if ( resultColors->resultType() != RimDefines::FORMATION_NAMES )
+                {
+                    resultColors->legendConfig()->setIntegerCategories(cellResultsData->uniqueCellScalarValues(resultColors->scalarResultIndex()));
+                }
+                else
+                {
+                    const std::vector<QString>& fnVector = eclipseCase()->reservoirData()->activeFormationNames()->formationNames();
+                    resultColors->legendConfig()->setNamedCategoriesInverse(fnVector);
+                }
+            }
+
+            m_viewer->addColorLegendToBottomLeftCorner(resultColors->legendConfig()->legend());
+            resultColors->legendConfig()->setTitle(cvfqt::Utils::toString(legendLabel + resultColors->resultVariable()));
+        }
     }
 
 

ApplicationCode/ProjectDataModel/RimFlowDiagSolution.cpp

@@ -20,6 +20,9 @@
 #include "RimEclipseResultCase.h"
 #include "RigCaseData.h"
 
+#include "RigFlowDiagResults.h"
+#include "RigCaseCellResultsData.h"
+
 CAF_PDM_SOURCE_INIT(RimFlowDiagSolution, "FlowDiagSolution");
 
 //--------------------------------------------------------------------------------------------------
@@ -32,6 +35,9 @@ RimFlowDiagSolution::RimFlowDiagSolution(void)
     //CAF_PDM_InitFieldNoDefault(&m_selectedWells, "SelectedWells", "Selected Wells","","");
 
     CAF_PDM_InitField(&m_userDescription, "UserDescription", QString("All Wells") ,"Description", "", "","");
+
+   
+
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -42,6 +48,30 @@ RimFlowDiagSolution::~RimFlowDiagSolution(void)
 
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagResults* RimFlowDiagSolution::flowDiagResults()
+{
+    if ( m_flowDiagResults.isNull() )
+    {
+        size_t timeStepCount;
+        {
+            RimEclipseResultCase* eclCase;
+            this->firstAncestorOrThisOfType(eclCase);
+            
+            CVF_ASSERT(eclCase && eclCase->reservoirData() && eclCase->reservoirData() );
+
+            timeStepCount = eclCase->reservoirData()->results(RifReaderInterface::MATRIX_RESULTS)->maxTimeStepCount();
+
+        }
+
+        m_flowDiagResults = new RigFlowDiagResults(this, timeStepCount);
+    }
+
+    return m_flowDiagResults.p();
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -65,6 +95,82 @@ std::set<QString> RimFlowDiagSolution::tracerNames()
     return tracerNameSet;
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::map<std::string, std::vector<int> > RimFlowDiagSolution::allInjectorTracerActiveCellIndices(size_t timeStepIndex)
+{
+    return allTracerActiveCellIndices(timeStepIndex, true);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::map<std::string, std::vector<int> > RimFlowDiagSolution::allProducerTracerActiveCellIndices(size_t timeStepIndex)
+{
+    return allTracerActiveCellIndices(timeStepIndex, false);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::map<std::string, std::vector<int> > RimFlowDiagSolution::allTracerActiveCellIndices(size_t timeStepIndex, bool useInjectors)
+{
+    RimEclipseResultCase* eclCase;
+    this->firstAncestorOrThisOfType(eclCase);
+    TracerStatusType tracerStatus = UNDEFINED;
+
+    std::map<std::string, std::vector<int> > tracersWithCells;
+
+    if ( eclCase )
+    {
+        const cvf::Collection<RigSingleWellResultsData>& wellResults = eclCase->reservoirData()->wellResults();
+        RigMainGrid* mainGrid = eclCase->reservoirData()->mainGrid();
+        RigActiveCellInfo* activeCellInfo = eclCase->reservoirData()->activeCellInfo(RifReaderInterface::MATRIX_RESULTS); //Todo: Must come from the results definition
+
+        for ( size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx )
+        {
+            if (!wellResults[wIdx]->hasWellResult(timeStepIndex) ) continue;
+            
+            size_t wellTimeStep = wellResults[wIdx]->m_resultTimeStepIndexToWellTimeStepIndex[timeStepIndex];
+            const RigWellResultFrame& wellResFrame =  wellResults[wIdx]->m_wellCellsTimeSteps[wellTimeStep];
+
+            if ( !wellResFrame.m_isOpen ) continue;
+
+            bool useWell = ( useInjectors && ( wellResFrame.m_productionType == RigWellResultFrame::GAS_INJECTOR
+                                            || wellResFrame.m_productionType == RigWellResultFrame::OIL_INJECTOR
+                                            ||  wellResFrame.m_productionType == RigWellResultFrame::WATER_INJECTOR) )
+                           || (!useInjectors && wellResFrame.m_productionType == RigWellResultFrame::PRODUCER);
+
+            
+            if (useWell)
+            {
+                std::string wellname = wellResults[wIdx]->m_wellName.toStdString();
+                std::vector<int>& tracerCells = tracersWithCells[wellname];
+
+                for (const RigWellResultBranch& wBr: wellResFrame.m_wellResultBranches)
+                {
+                    for (const RigWellResultPoint& wrp: wBr.m_branchResultPoints)
+                    {
+                        if (wrp.isValid() && wrp.m_isOpen)
+                        {
+                            RigGridBase * grid = mainGrid->gridByIndex(wrp.m_gridIndex);
+                            size_t reservoirCellIndex = grid->reservoirCellIndex(wrp.m_gridCellIndex);
+
+                            int cellActiveIndex = static_cast<int>(activeCellInfo->cellResultIndex(reservoirCellIndex));
+                            tracerCells.push_back(cellActiveIndex);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    return tracersWithCells;
+}
+
+
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/RimFlowDiagSolution.h

@@ -23,8 +23,11 @@
 #include "cafPdmPointer.h"
 #include "cafAppEnum.h"
 
-class RimEclipseWell;
+#include "cvfBase.h"
+#include "cvfObject.h"
 
+class RimEclipseWell;
+class RigFlowDiagResults;
 //==================================================================================================
 ///  
 ///  
@@ -33,12 +36,15 @@ class RimFlowDiagSolution : public caf::PdmObject
 {
      CAF_PDM_HEADER_INIT;
 public:
-    RimFlowDiagSolution(void);
-    virtual ~RimFlowDiagSolution(void);
+    RimFlowDiagSolution();
+    virtual ~RimFlowDiagSolution();
 
-    QString userDescription() { return m_userDescription();} 
+    QString             userDescription() { return m_userDescription();} 
+    RigFlowDiagResults* flowDiagResults();
+    std::set<QString>   tracerNames();
 
-    std::set<QString> tracerNames();
+    std::map<std::string, std::vector<int> > allInjectorTracerActiveCellIndices(size_t timeStepIndex);
+    std::map<std::string, std::vector<int> > allProducerTracerActiveCellIndices(size_t timeStepIndex);
 
     enum TracerStatusType
     {
@@ -50,12 +56,17 @@ public:
 
     TracerStatusType tracerStatus(QString tracerName);
 
+
 protected:
     //virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;
 
 private:
+    std::map<std::string, std::vector<int> > allTracerActiveCellIndices(size_t timeStepIndex, bool useInjectors);
+
     virtual caf::PdmFieldHandle* userDescriptionField() override;
     caf::PdmField<QString> m_userDescription;
 
+    cvf::ref<RigFlowDiagResults> m_flowDiagResults;
+
     //caf::PdmPtrArrayField<RimEclipseWell*> m_selectedWells;
 };

ApplicationCode/ProjectDataModel/RimMultiSnapshotDefinition.cpp

@@ -19,7 +19,11 @@
 #include "RimMultiSnapshotDefinition.h"
 
 #include "RiaApplication.h"
+
+#include "RigActiveCellInfo.h"
+
 #include "RimCase.h"
+#include "RimCellRangeFilterCollection.h"
 #include "RimProject.h"
 #include "RimView.h"
 
@@ -33,6 +37,7 @@ namespace caf
         addItem(RimMultiSnapshotDefinition::RANGEFILTER_I, "I", "i-direction");
         addItem(RimMultiSnapshotDefinition::RANGEFILTER_J, "J", "j-direction");
         addItem(RimMultiSnapshotDefinition::RANGEFILTER_K, "K", "k-direction");
+        addItem(RimMultiSnapshotDefinition::NO_RANGEFILTER, "None", "None");
 
         setDefault(RimMultiSnapshotDefinition::RANGEFILTER_K);
     }
@@ -48,16 +53,15 @@ RimMultiSnapshotDefinition::RimMultiSnapshotDefinition()
     //CAF_PDM_InitObject("MultiSnapshotDefinition", ":/Well.png", "", "");
     CAF_PDM_InitObject("MultiSnapshotDefinition", "", "", "");
 
-    CAF_PDM_InitFieldNoDefault(&caseObject,     "Case",                 "Case", "", "", "");
     CAF_PDM_InitFieldNoDefault(&viewObject,     "View",                 "View", "", "", "");
     CAF_PDM_InitField(&timeStepStart,           "TimeStepStart", 0,     "Timestep Start", "", "", "");
     CAF_PDM_InitField(&timeStepEnd,             "TimeStepEnd", 0,       "Timestep End", "", "", "");
 
-    CAF_PDM_InitField(&sliceDirection, "SnapShotDirection", caf::AppEnum<SnapShotDirectionEnum>(RANGEFILTER_K), "Range Filter direction", "", "", "");
-    CAF_PDM_InitField(&startSliceIndex, "RangeFilterStart", 0, "RangeFilter Start", "", "", "");
-    CAF_PDM_InitField(&endSliceIndex, "RangeFilterEnd", 0, "RangeFilter End", "", "", "");
-
+    CAF_PDM_InitField(&sliceDirection,          "SnapShotDirection",    caf::AppEnum<SnapShotDirectionEnum>(NO_RANGEFILTER), "Range Filter direction", "", "", "");
+    CAF_PDM_InitField(&startSliceIndex,         "RangeFilterStart", 1,  "RangeFilter Start", "", "", "");
+    CAF_PDM_InitField(&endSliceIndex,           "RangeFilterEnd", 1,    "RangeFilter End", "", "", "");
 
+    CAF_PDM_InitFieldNoDefault(&additionalCases, "AdditionalCases",     "Additional Cases", "", "", "");
 }
 
 
@@ -77,41 +81,50 @@ QList<caf::PdmOptionItemInfo> RimMultiSnapshotDefinition::calculateValueOptions(
 
     RimProject* proj = RiaApplication::instance()->project();
 
-    if (fieldNeedingOptions == &caseObject && proj)
+    if (fieldNeedingOptions == &viewObject)
     {
+        std::vector<RimView*> views; 
+
+        RimProject* proj = RiaApplication::instance()->project();
         std::vector<RimCase*> cases;
         proj->allCases(cases);
 
-        for (RimCase* c : cases)
+        for (RimCase* rimCase : cases)
         {
-            options.push_back(caf::PdmOptionItemInfo(c->caseUserDescription(), QVariant::fromValue(caf::PdmPointer<caf::PdmObjectHandle>(c))));
-        }
-
-        //options.push_back(caf::PdmOptionItemInfo("All", QVariant::fromValue(caf::PdmPointer<caf::PdmObjectHandle>(nullptr))));
-    }
-    else if (fieldNeedingOptions == &viewObject)
-    {
-        if (caseObject())
-        {
-            std::vector<RimView*> views = caseObject()->views();
-            for (RimView* view : views)
+            for (RimView* rimView : rimCase->views())
             {
-                options.push_back(caf::PdmOptionItemInfo(view->name(), QVariant::fromValue(caf::PdmPointer<caf::PdmObjectHandle>(view))));
+                views.push_back(rimView);
             }
         }
 
-        //options.push_back(caf::PdmOptionItemInfo("All", QVariant::fromValue(caf::PdmPointer<caf::PdmObjectHandle>(nullptr))));
+        for (RimView* view : views)
+        {
+            QString caseAndView = view->ownerCase()->caseUserDescription() + " - " + view->name();
+            options.push_back(caf::PdmOptionItemInfo(caseAndView, view));
+        }
+        options.push_back(caf::PdmOptionItemInfo("-- All views --", nullptr));
     }
     else if (fieldNeedingOptions == &timeStepEnd)
     {
         getTimeStepStrings(options);
-
     }
     else if (fieldNeedingOptions == &timeStepStart)
     {
         getTimeStepStrings(options);
     }
+    else if (fieldNeedingOptions == &additionalCases)
+    {
+        RimProject* proj = RiaApplication::instance()->project();
+        std::vector<RimCase*> cases;
+        proj->allCases(cases);
 
+        for (RimCase* rimCase : cases)
+        {
+            options.push_back(caf::PdmOptionItemInfo(rimCase->caseUserDescription(), rimCase));
+        }
+
+        if (useOptionsOnly) *useOptionsOnly = true;
+    }
 
     return options;
 }
@@ -121,13 +134,72 @@ QList<caf::PdmOptionItemInfo> RimMultiSnapshotDefinition::calculateValueOptions(
 //--------------------------------------------------------------------------------------------------
 void RimMultiSnapshotDefinition::getTimeStepStrings(QList<caf::PdmOptionItemInfo> &options)
 {
-    if (!caseObject()) return;
-    
-    QStringList timeSteps = caseObject()->timeStepStrings();
+    QStringList timeSteps;
+
+    timeSteps = viewObject->ownerCase()->timeStepStrings();
+
     for (int i = 0; i < timeSteps.size(); i++)
     {
         options.push_back(caf::PdmOptionItemInfo(timeSteps[i], i));
     }
-    
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RimMultiSnapshotDefinition::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
+{
+
+    if (changedField == &sliceDirection)
+    {
+        const cvf::StructGridInterface* mainGrid = nullptr;
+        RigActiveCellInfo* actCellInfo = nullptr;
+       
+        if (viewObject())
+        {
+            mainGrid = viewObject()->rangeFilterCollection()->gridByIndex(0);
+            actCellInfo = viewObject()->rangeFilterCollection()->activeCellInfo();
+        }
+
+        if (mainGrid && actCellInfo)
+        {
+            cvf::Vec3st min, max;
+            actCellInfo->IJKBoundingBox(min, max);
+
+            // Adjust to Eclipse indexing
+            min.x() = min.x() + 1;
+            min.y() = min.y() + 1;
+            min.z() = min.z() + 1;
+
+            max.x() = max.x() + 1;
+            max.y() = max.y() + 1;
+            max.z() = max.z() + 1;
+
+            int maxInt = 0;
+            int minInt = 0;
+
+            if (newValue == RimMultiSnapshotDefinition::RANGEFILTER_I)
+            {
+                maxInt = static_cast<int>(max.x());
+                minInt = static_cast<int>(min.x());
+            }
+            else if (newValue == RimMultiSnapshotDefinition::RANGEFILTER_J)
+            {
+                maxInt = static_cast<int>(max.y());
+                minInt = static_cast<int>(min.y());
+            }
+            else if (newValue == RimMultiSnapshotDefinition::RANGEFILTER_K)
+            {
+                maxInt = static_cast<int>(max.z());
+                minInt = static_cast<int>(min.z());
+            }
+                
+            startSliceIndex = minInt;
+            endSliceIndex = maxInt;
+
+        }
+       
+        startSliceIndex.uiCapability()->updateConnectedEditors();
+    }
 }
 

ApplicationCode/ProjectDataModel/RimMultiSnapshotDefinition.h

@@ -18,10 +18,11 @@
 
 #pragma once
 
+#include "cafAppEnum.h"
 #include "cafPdmField.h"
 #include "cafPdmObject.h"
 #include "cafPdmPtrField.h"
-#include "cafAppEnum.h"
+#include "cafPdmPtrArrayField.h"
 
 class RimCase;
 class RimView;
@@ -37,7 +38,6 @@ public:
     RimMultiSnapshotDefinition();
     virtual ~RimMultiSnapshotDefinition();
 
-    caf::PdmPtrField<RimCase*>  caseObject;
     caf::PdmPtrField<RimView*>  viewObject;
 
     caf::PdmField<int>       timeStepStart;
@@ -47,16 +47,20 @@ public:
     {
         RANGEFILTER_I,
         RANGEFILTER_J,
-        RANGEFILTER_K
+        RANGEFILTER_K,
+        NO_RANGEFILTER
     };
 
     caf::PdmField< caf::AppEnum< SnapShotDirectionEnum > > sliceDirection;
     caf::PdmField<int>       startSliceIndex;
     caf::PdmField<int>       endSliceIndex;
 
+    caf::PdmPtrArrayField<RimCase*>  additionalCases;
+
 
     virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;
 
     void getTimeStepStrings(QList<caf::PdmOptionItemInfo> &options);
-
+    
+    virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
 };

ApplicationCode/ProjectDataModel/RimProject.cpp

@@ -180,6 +180,8 @@ void RimProject::close()
 
     commandObjects.deleteAllChildObjects();
 
+    multiSnapshotDefinitions.deleteAllChildObjects();
+
     delete viewLinkerCollection->viewLinker();
     viewLinkerCollection->viewLinker = NULL;
 

ApplicationCode/ProjectDataModel/RimViewController.cpp

@@ -67,6 +67,7 @@ RimViewController::RimViewController(void)
     m_managedView.uiCapability()->setUiTreeChildrenHidden(true);
 
     CAF_PDM_InitField(&m_syncCamera,            "SyncCamera", true,             "Camera", "", "", "");
+    CAF_PDM_InitField(&m_showCursor,            "ShowCursor", true,             "   Show Cursor", "", "", "");
     CAF_PDM_InitField(&m_syncTimeStep,          "SyncTimeStep", true,           "Time Step", "", "", "");
     CAF_PDM_InitField(&m_syncCellResult,        "SyncCellResult", false,        "Cell Result", "", "", "");
     CAF_PDM_InitField(&m_syncLegendDefinitions, "SyncLegendDefinitions", true,  "   Legend Definition", "", "", "");
@@ -174,6 +175,13 @@ void RimViewController::fieldChangedByUi(const caf::PdmFieldHandle* changedField
     {
         updateTimeStepLink();
     }
+    else if (changedField == &m_showCursor)
+    {
+        if (!m_showCursor && m_managedView && m_managedView->viewer())
+        {
+            m_managedView->viewer()->setCursorPosition(cvf::Vec3d::UNDEFINED);
+        }
+    }
     else if (changedField == &m_syncCellResult)
     {
         updateResultColorsControl();
@@ -223,7 +231,7 @@ void RimViewController::fieldChangedByUi(const caf::PdmFieldHandle* changedField
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimEclipseView* RimViewController::managedEclipseView()
+RimEclipseView* RimViewController::managedEclipseView() const
 {
     RimView* rimView = m_managedView;
 
@@ -233,7 +241,7 @@ RimEclipseView* RimViewController::managedEclipseView()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimGeoMechView* RimViewController::managedGeoView()
+RimGeoMechView* RimViewController::managedGeoView() const
 {
     RimView* rimView = m_managedView;
 
@@ -418,13 +426,23 @@ void RimViewController::updateOptionSensitivity()
         this->m_syncRangeFilters = false;
     }
 
+    if (m_syncCamera)
+    {
+        this->m_showCursor.uiCapability()->setUiReadOnly(false);
+    }
+    else
+    {
+        this->m_showCursor.uiCapability()->setUiReadOnly(true);
+        this->m_showCursor = false;
+    }
+
     m_syncVisibleCells.uiCapability()->setUiReadOnly(!this->isMasterAndDepViewDifferentType());
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimView* RimViewController::managedView()
+RimView* RimViewController::managedView() const
 {
     return m_managedView;
 }
@@ -455,6 +473,7 @@ void RimViewController::defineUiOrdering(QString uiConfigName, caf::PdmUiOrderin
     caf::PdmUiGroup* scriptGroup = uiOrdering.addNewGroup("Link Options");
 
     scriptGroup->add(&m_syncCamera);
+    scriptGroup->add(&m_showCursor);
     scriptGroup->add(&m_syncTimeStep);
     scriptGroup->add(&m_syncCellResult);
     scriptGroup->add(&m_syncLegendDefinitions);
@@ -530,7 +549,7 @@ void RimViewController::updateLegendDefinitions()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimViewLinker* RimViewController::ownerViewLinker()
+RimViewLinker* RimViewController::ownerViewLinker() const
 {
     RimViewLinker* viewLinker = NULL;
     this->firstAncestorOrThisOfType(viewLinker);
@@ -609,7 +628,7 @@ const RigCaseToCaseCellMapper* RimViewController::cellMapper()
         }
          else if (masterFemPart && dependEclGrid)
         {
-             m_caseToCaseCellMapper = new RigCaseToCaseCellMapper(masterFemPart, dependEclGrid);
+            m_caseToCaseCellMapper = new RigCaseToCaseCellMapper(masterFemPart, dependEclGrid);
         }
     }
 
@@ -619,7 +638,7 @@ const RigCaseToCaseCellMapper* RimViewController::cellMapper()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimView* RimViewController::masterView()
+RimView* RimViewController::masterView() const
 {
     return ownerViewLinker()->masterView();
 }
@@ -627,7 +646,7 @@ RimView* RimViewController::masterView()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isMasterAndDepViewDifferentType()
+bool RimViewController::isMasterAndDepViewDifferentType() const
 {
     RimEclipseView* eclipseMasterView = dynamic_cast<RimEclipseView*>(masterView());
     RimGeoMechView* geoMasterView = dynamic_cast<RimGeoMechView*>(masterView());
@@ -648,7 +667,7 @@ bool RimViewController::isMasterAndDepViewDifferentType()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimViewController::scheduleCreateDisplayModelAndRedrawForDependentView()
+void RimViewController::scheduleCreateDisplayModelAndRedrawForDependentView() const
 {
     if (!this->isActive()) return;
 
@@ -668,7 +687,7 @@ void RimViewController::scheduleCreateDisplayModelAndRedrawForDependentView()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimViewController::scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType)
+void RimViewController::scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType) const
 {
     if (!this->isActive()) return;
 
@@ -693,7 +712,7 @@ void RimViewController::scheduleGeometryRegenForDepViews(RivCellSetEnum geometry
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isActive()
+bool RimViewController::isActive() const
 {
     return ownerViewLinker()->isActive() && this->m_isActive();
 }
@@ -701,7 +720,7 @@ bool RimViewController::isActive()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isCameraLinked()
+bool RimViewController::isCameraLinked() const
 {
     if (ownerViewLinker()->isActive() && this->m_isActive())
     {
@@ -716,7 +735,15 @@ bool RimViewController::isCameraLinked()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isTimeStepLinked()
+bool RimViewController::showCursor() const
+{
+    return m_showCursor;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+bool RimViewController::isTimeStepLinked() const
 {
     if (ownerViewLinker()->isActive() && this->m_isActive())
     {
@@ -731,7 +758,7 @@ bool RimViewController::isTimeStepLinked()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isResultColorControlled()
+bool RimViewController::isResultColorControlled() const
 {
    if (ownerViewLinker()->isActive() && this->m_isActive())
     {
@@ -746,7 +773,7 @@ bool RimViewController::isResultColorControlled()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isLegendDefinitionsControlled()
+bool RimViewController::isLegendDefinitionsControlled() const
 {
     if (ownerViewLinker()->isActive() && this->m_isActive())
     {
@@ -761,7 +788,7 @@ bool RimViewController::isLegendDefinitionsControlled()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isVisibleCellsOveridden()
+bool RimViewController::isVisibleCellsOveridden() const
 {
     if (isMasterAndDepViewDifferentType())
     {
@@ -783,7 +810,7 @@ bool RimViewController::isVisibleCellsOveridden()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isRangeFilterControlPossible()
+bool RimViewController::isRangeFilterControlPossible() const
 {
     return true;
     #if 0
@@ -817,7 +844,7 @@ bool RimViewController::isRangeFilterControlPossible()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isRangeFilterMappingApliccable()
+bool RimViewController::isRangeFilterMappingApliccable() const
 {
     if (!isMasterAndDepViewDifferentType()) return false;
 
@@ -850,7 +877,7 @@ bool RimViewController::isRangeFilterMappingApliccable()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isRangeFiltersControlled()
+bool RimViewController::isRangeFiltersControlled() const
 {
     if (!isRangeFilterControlPossible()) return false;
 
@@ -866,7 +893,7 @@ bool RimViewController::isRangeFiltersControlled()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isPropertyFilterControlPossible()
+bool RimViewController::isPropertyFilterControlPossible() const
 {
     // The cases need to be the same 
     RimGeoMechView* geomView = dynamic_cast<RimGeoMechView*>(masterView());
@@ -898,7 +925,7 @@ bool RimViewController::isPropertyFilterControlPossible()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewController::isPropertyFilterOveridden()
+bool RimViewController::isPropertyFilterOveridden() const
 {
    if (!isPropertyFilterControlPossible()) return false;
 

ApplicationCode/ProjectDataModel/RimViewController.h

@@ -47,28 +47,29 @@ public:
     RimViewController(void);
     virtual ~RimViewController(void);
 
-    bool                                    isActive();
+    bool                                    isActive() const;
 
-    RimView*                                managedView();
+    RimView*                                managedView() const;
     void                                    setManagedView(RimView* view);
 
-    RimView*                                masterView();
-    RimViewLinker*                          ownerViewLinker();
+    RimView*                                masterView() const;
+    RimViewLinker*                          ownerViewLinker() const;
 
     const RigCaseToCaseCellMapper*          cellMapper();
     
-    bool                                    isCameraLinked();
-    bool                                    isTimeStepLinked();
+    bool                                    isCameraLinked() const;
+    bool                                    showCursor() const;
+    bool                                    isTimeStepLinked() const;
 
-    bool                                    isResultColorControlled();
-    bool                                    isLegendDefinitionsControlled();
-    bool                                    isRangeFiltersControlled();
+    bool                                    isResultColorControlled() const;
+    bool                                    isLegendDefinitionsControlled() const;
+    bool                                    isRangeFiltersControlled() const;
     
-    bool                                    isVisibleCellsOveridden();
-    bool                                    isPropertyFilterOveridden();
+    bool                                    isVisibleCellsOveridden() const;
+    bool                                    isPropertyFilterOveridden() const;
 
-    void                                    scheduleCreateDisplayModelAndRedrawForDependentView();
-    void                                    scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType);
+    void                                    scheduleCreateDisplayModelAndRedrawForDependentView() const;
+    void                                    scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType) const;
     void                                    updateOverrides();
     void                                    updateOptionSensitivity();
     void                                    removeOverrides();
@@ -93,24 +94,27 @@ private:
     void                                    updateResultColorsControl();
     void                                    updateLegendDefinitions();
 
-    bool                                    isMasterAndDepViewDifferentType();
-    bool                                    isRangeFilterControlPossible();
-    bool                                    isPropertyFilterControlPossible();
-    bool                                    isRangeFilterMappingApliccable();
+    bool                                    isMasterAndDepViewDifferentType() const;
+    bool                                    isRangeFilterControlPossible() const;
+    bool                                    isPropertyFilterControlPossible() const;
+    bool                                    isRangeFilterMappingApliccable() const;
 
-    RimEclipseView*                         managedEclipseView();
-    RimGeoMechView*                         managedGeoView();
+    RimEclipseView*                         managedEclipseView() const;
+    RimGeoMechView*                         managedGeoView() const;
+    
     static void                             removeOverrides(RimView* view);
-
     static bool                             askUserToRestoreOriginalRangeFilterCollection(const QString& viewName);
+
 private:
     caf::PdmField<QString>                  m_name;
     caf::PdmPtrField<RimView*>              m_managedView;
 
     caf::PdmField<bool>                     m_isActive;
     caf::PdmField<bool>                     m_syncCamera;
+    caf::PdmField<bool>                     m_showCursor;
     caf::PdmField<bool>                     m_syncTimeStep;
 
+
     // Overridden properties
     caf::PdmField<bool>                     m_syncCellResult;
     caf::PdmField<bool>                     m_syncLegendDefinitions;

ApplicationCode/ProjectDataModel/RimViewLinker.cpp

@@ -142,9 +142,7 @@ void RimViewLinker::updateCellResult()
                 {
                     if (viewLink->isResultColorControlled())
                     {
-                        eclipeView->cellResult()->setPorosityModel(eclipseCellResultDefinition->porosityModel());
-                        eclipeView->cellResult()->setResultType(eclipseCellResultDefinition->resultType());
-                        eclipeView->cellResult()->setResultVariable(eclipseCellResultDefinition->resultVariable());
+                        eclipeView->cellResult()->simpleCopy(eclipseCellResultDefinition);
 
                         if (viewLink->isLegendDefinitionsControlled())
                         {
@@ -247,7 +245,7 @@ void RimViewLinker::removeOverrides()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::allViewsForCameraSync(RimView* source, std::vector<RimView*>& views)
+void RimViewLinker::allViewsForCameraSync(const RimView* source, std::vector<RimView*>& views) const
 {
     if (!isActive()) return;
 
@@ -322,7 +320,7 @@ void RimViewLinker::setMasterView(RimView* view)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-RimView* RimViewLinker::masterView()
+RimView* RimViewLinker::masterView() const
 {
     return m_masterView;
 }
@@ -330,7 +328,7 @@ RimView* RimViewLinker::masterView()
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::allViews(std::vector<RimView*>& views)
+void RimViewLinker::allViews(std::vector<RimView*>& views) const
 {
     views.push_back(m_masterView());
 
@@ -382,7 +380,7 @@ void RimViewLinker::updateScaleZ(RimView* sourceView, double scaleZ)
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-bool RimViewLinker::isActive()
+bool RimViewLinker::isActive() const
 {
     RimViewLinkerCollection* viewLinkerCollection = NULL;
     this->firstAncestorOrThisOfType(viewLinkerCollection);
@@ -482,6 +480,40 @@ void RimViewLinker::findNameAndIconFromView(QString* name, QIcon* icon, RimView*
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RimViewLinker::updateCursorPosition(const RimView* sourceView, const cvf::Vec3d& domainCoord)
+{
+    RimViewController* sourceViewLink = sourceView->viewController();
+    if (sourceViewLink && !sourceViewLink->showCursor())
+    {
+        return;
+    }
+
+    std::vector<RimView*> viewsToUpdate;
+    allViewsForCameraSync(sourceView, viewsToUpdate);
+
+    for (RimView* destinationView : viewsToUpdate)
+    {
+        if (destinationView == sourceView) continue;
+
+        if (destinationView != m_masterView)
+        {
+            RimViewController* viewLink = destinationView->viewController();
+            if (!viewLink) continue;
+
+            if (!viewLink->showCursor()) continue;
+        }
+
+        RiuViewer* destinationViewer = destinationView->viewer();
+        if (destinationViewer)
+        {
+            destinationViewer->setCursorPosition(domainCoord);
+        }
+    }
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -626,18 +658,16 @@ void RimViewLinker::addDependentView(RimView* view)
     this->m_viewControllers.push_back(viewContr);
 
     viewContr->setManagedView(view);
-
-
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RimViewLinker::addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering)
+void RimViewLinker::addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering) const
 {
     for (size_t j = 0; j < m_viewControllers.size(); j++)
     {
-        uiTreeOrdering.add(m_viewControllers()[j]);
+        uiTreeOrdering.add(m_viewControllers[j]);
     }
 }
 

ApplicationCode/ProjectDataModel/RimViewLinker.h

@@ -28,6 +28,9 @@
 #include "cafPdmObject.h"
 #include "cafPdmPtrField.h"
 
+#include "cvfBase.h"
+#include "cvfVector3.h"
+
 namespace cvf
 {
     class BoundingBox;
@@ -50,10 +53,10 @@ public:
     RimViewLinker(void);
     virtual ~RimViewLinker(void);
     
-    bool                                    isActive();
+    bool                                    isActive() const;
 
     void                                    setMasterView(RimView* view);
-    RimView*                                masterView();
+    RimView*                                masterView() const;
 
     void                                    addDependentView(RimView* view);
     void                                    updateDependentViews();
@@ -73,15 +76,17 @@ public:
     void                                    scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType);
     void                                    scheduleCreateDisplayModelAndRedrawForDependentViews();
 
-    void                                    allViews(std::vector<RimView*>& views);
+    void                                    allViews(std::vector<RimView*>& views) const;
 
     void                                    updateUiNameAndIcon();
 
-    void                                    addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering);
+    void                                    addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering) const;
 
     static void                             applyIconEnabledState(caf::PdmObject* obj, const QIcon& icon, bool disable);
     static void                             findNameAndIconFromView(QString* name, QIcon* icon, RimView* view);
 
+    void                                    updateCursorPosition(const RimView* sourceView, const cvf::Vec3d& domainCoord);
+
 public:
     static QString                          displayNameForView(RimView* view);
 
@@ -90,7 +95,7 @@ protected:
     virtual void                            initAfterRead();
 
 private:
-    void                                    allViewsForCameraSync(RimView* source, std::vector<RimView*>& views);
+    void                                    allViewsForCameraSync(const RimView* source, std::vector<RimView*>& views) const;
     
     void                                    removeOverrides();
 

ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp

@@ -113,6 +113,30 @@ void RimWellLogExtractionCurve::setWellPath(RimWellPath* wellPath)
     m_wellPath = wellPath;
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RimWellPath* RimWellLogExtractionCurve::wellPath() const
+{
+    return m_wellPath;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RimWellLogExtractionCurve::setCase(RimCase* rimCase)
+{
+    m_case = rimCase;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RimCase* RimWellLogExtractionCurve::rimCase() const
+{
+    return m_case;
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -128,8 +152,8 @@ void RimWellLogExtractionCurve::setPropertiesFromView(RimView* view)
     RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>(view);
     if (eclipseView)
     {
-        m_eclipseResultDefinition->setResultType(eclipseView->cellResult()->resultType());
-        m_eclipseResultDefinition->setResultVariable(eclipseView->cellResult()->resultVariable());
+        m_eclipseResultDefinition->simpleCopy(eclipseView->cellResult());
+
         m_timeStep = eclipseView->currentTimeStep();
     }
 
@@ -224,11 +248,10 @@ void RimWellLogExtractionCurve::onLoadDataAndUpdate()
 
             m_eclipseResultDefinition->loadResult();
 
-            cvf::ref<RigResultAccessor> resAcc = RigResultAccessorFactory::createResultAccessor(
-                eclipseCase->reservoirData(),
-                0,
-                m_timeStep,
-                m_eclipseResultDefinition);
+            cvf::ref<RigResultAccessor> resAcc = RigResultAccessorFactory::createFromResultDefinition(eclipseCase->reservoirData(),
+                                                                                                      0,
+                                                                                                      m_timeStep,
+                                                                                                      m_eclipseResultDefinition);
 
             if (resAcc.notNull())
             {

ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.h

@@ -41,8 +41,12 @@ public:
     RimWellLogExtractionCurve();
     virtual ~RimWellLogExtractionCurve();
     
-    
     void setWellPath(RimWellPath* wellPath);
+    RimWellPath* wellPath() const;
+
+    void setCase(RimCase* rimCase);
+    RimCase* rimCase() const;
+
     void setPropertiesFromView(RimView* view);
 
     virtual QString wellName() const;

ApplicationCode/ReservoirDataModel/CMakeLists_files.cmake

@@ -20,6 +20,13 @@ ${CEE_CURRENT_LIST_DIR}RigCombMultResultAccessor.h
 ${CEE_CURRENT_LIST_DIR}RigResultModifier.h
 ${CEE_CURRENT_LIST_DIR}RigResultModifierFactory.h
 ${CEE_CURRENT_LIST_DIR}RigFormationNames.h
+${CEE_CURRENT_LIST_DIR}RigFlowDiagResultAddress.h
+${CEE_CURRENT_LIST_DIR}RigFlowDiagResults.h
+${CEE_CURRENT_LIST_DIR}RigFlowDiagResultFrames.h
+${CEE_CURRENT_LIST_DIR}RigFlowDiagSolverInterface.h
+${CEE_CURRENT_LIST_DIR}RigFlowDiagInterfaceTools.h
+${CEE_CURRENT_LIST_DIR}RigFlowDiagStatCalc.h
+${CEE_CURRENT_LIST_DIR}RigFlowDiagVisibleCellsStatCalc.h
 ${CEE_CURRENT_LIST_DIR}RigWellLogExtractor.h
 ${CEE_CURRENT_LIST_DIR}RigEclipseWellLogExtractor.h
 ${CEE_CURRENT_LIST_DIR}RigLocalGrid.h
@@ -59,6 +66,11 @@ ${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}RigFlowDiagResults.cpp
+${CEE_CURRENT_LIST_DIR}RigFlowDiagResultFrames.cpp
+${CEE_CURRENT_LIST_DIR}RigFlowDiagSolverInterface.cpp
+${CEE_CURRENT_LIST_DIR}RigFlowDiagStatCalc.cpp
+${CEE_CURRENT_LIST_DIR}RigFlowDiagVisibleCellsStatCalc.cpp
 ${CEE_CURRENT_LIST_DIR}RigWellLogExtractor.cpp
 ${CEE_CURRENT_LIST_DIR}RigEclipseWellLogExtractor.cpp
 ${CEE_CURRENT_LIST_DIR}RigLocalGrid.cpp

ApplicationCode/ReservoirDataModel/RigActiveCellsResultAccessor.cpp

@@ -25,7 +25,7 @@
 #include <cmath>
 
 
-RigActiveCellsResultAccessor::RigActiveCellsResultAccessor(const RigGridBase* grid, std::vector<double>* reservoirResultValues, const RigActiveCellInfo* activeCellInfo)
+RigActiveCellsResultAccessor::RigActiveCellsResultAccessor(const RigGridBase* grid, const std::vector<double>* reservoirResultValues, const RigActiveCellInfo* activeCellInfo)
     : m_grid(grid),
     m_reservoirResultValues(reservoirResultValues),
     m_activeCellInfo(activeCellInfo)

ApplicationCode/ReservoirDataModel/RigActiveCellsResultAccessor.h

@@ -31,7 +31,7 @@ class RigActiveCellInfo;
 class RigActiveCellsResultAccessor : public RigResultAccessor
 {
 public:
-    RigActiveCellsResultAccessor(const RigGridBase* grid, std::vector<double>* reservoirResultValues, const RigActiveCellInfo* activeCellInfo);
+    RigActiveCellsResultAccessor(const RigGridBase* grid, const std::vector<double>* reservoirResultValues, const RigActiveCellInfo* activeCellInfo);
 
     virtual double  cellScalar(size_t gridLocalCellIndex) const;
     virtual double  cellFaceScalar(size_t gridLocalCellIndex, cvf::StructGridInterface::FaceType faceId) const;
@@ -42,6 +42,6 @@ public:
 private:
     const RigActiveCellInfo*    m_activeCellInfo;
     const RigGridBase*          m_grid;
-    std::vector<double>*        m_reservoirResultValues;
+    const std::vector<double>*  m_reservoirResultValues;
 };
 

ApplicationCode/ReservoirDataModel/RigEclipseNativeStatCalc.h

@@ -21,33 +21,26 @@
 
 #include "RigStatisticsCalculator.h"
 
-#include "cvfBase.h"
-#include "cvfObject.h"
-#include "cvfCollection.h"
-
 class RigHistogramCalculator;
 class RigCaseCellResultsData;
 
 //==================================================================================================
 /// 
 //==================================================================================================
+
 class RigEclipseNativeStatCalc : public RigStatisticsCalculator
 {
 public:
     RigEclipseNativeStatCalc(RigCaseCellResultsData* cellResultsData, size_t scalarResultIndex);
 
-    virtual void minMaxCellScalarValues(size_t timeStepIndex, double& min, double& max);
-    virtual void posNegClosestToZero(size_t timeStepIndex, double& pos, double& neg);
-
-    virtual void valueSumAndSampleCount(size_t timeStepIndex, double& valueSum, size_t& sampleCount);
-
-    virtual void addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator);
-
+    virtual void    minMaxCellScalarValues(size_t timeStepIndex, double& min, double& max);
+    virtual void    posNegClosestToZero(size_t timeStepIndex, double& pos, double& neg);
+    virtual void    valueSumAndSampleCount(size_t timeStepIndex, double& valueSum, size_t& sampleCount);
+    virtual void    addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator);
     virtual void    uniqueValues(size_t timeStepIndex, std::set<int>& values);
-
     virtual size_t  timeStepCount();
 
 private:
     RigCaseCellResultsData* m_resultsData;
-    size_t m_scalarResultIndex;
+    size_t                  m_scalarResultIndex;
 };

ApplicationCode/ReservoirDataModel/RigFlowDiagInterfaceTools.h

@@ -0,0 +1,131 @@
+
+#pragma once
+
+
+#include <opm/flowdiagnostics/ConnectivityGraph.hpp>
+#include <opm/flowdiagnostics/ConnectionValues.hpp>
+#include <opm/flowdiagnostics/Toolbox.hpp>
+
+#include <opm/utility/ECLGraph.hpp>
+#include <opm/utility/ECLWellSolution.hpp>
+
+#include <exception>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace RigFlowDiagInterfaceTools {
+
+
+    inline Opm::FlowDiagnostics::ConnectionValues
+    extractFluxField(const Opm::ECLGraph& G)
+    {
+        using ConnVals = Opm::FlowDiagnostics::ConnectionValues;
+
+        using NConn = ConnVals::NumConnections;
+        using NPhas = ConnVals::NumPhases;
+
+        const auto nconn = NConn{G.numConnections()};
+        const auto nphas = NPhas{3};
+
+        auto flux = ConnVals(nconn, nphas);
+
+        auto phas = ConnVals::PhaseID{0};
+
+        for (const auto& p : { Opm::ECLGraph::PhaseIndex::Aqua   ,
+                               Opm::ECLGraph::PhaseIndex::Liquid ,
+                               Opm::ECLGraph::PhaseIndex::Vapour })
+        {
+            const std::vector<double> pflux = G.flux(p);
+
+            if (! pflux.empty()) {
+                assert (pflux.size() == nconn.total);
+
+                auto conn = ConnVals::ConnID{0};
+
+                for (const auto& v : pflux) {
+                    flux(conn, phas) = v;
+
+                    conn.id += 1;
+                }
+            }
+
+            phas.id += 1;
+        }
+
+        return flux;
+    }
+
+    template <class WellFluxes>
+    Opm::FlowDiagnostics::CellSetValues
+    extractWellFlows(const Opm::ECLGraph& G,
+                     const WellFluxes&    well_fluxes)
+    {
+        Opm::FlowDiagnostics::CellSetValues inflow;
+        for (const auto& well : well_fluxes) {
+            for (const auto& completion : well.completions) {
+                const int grid_index = completion.grid_index;
+                const auto& ijk = completion.ijk;
+                const int cell_index = G.activeCell(ijk, grid_index);
+                if (cell_index >= 0) {
+                    inflow.emplace(cell_index, completion.reservoir_inflow_rate);
+                }
+            }
+        }
+
+        return inflow;
+    }
+
+    namespace Hack {
+        inline Opm::FlowDiagnostics::ConnectionValues
+        convert_flux_to_SI(Opm::FlowDiagnostics::ConnectionValues&& fl)
+        {
+            using Co = Opm::FlowDiagnostics::ConnectionValues::ConnID;
+            using Ph = Opm::FlowDiagnostics::ConnectionValues::PhaseID;
+
+            const auto nconn = fl.numConnections();
+            const auto nphas = fl.numPhases();
+
+            for (auto phas = Ph{0}; phas.id < nphas; ++phas.id) {
+                for (auto conn = Co{0}; conn.id < nconn; ++conn.id) {
+                    fl(conn, phas) /= 86400;
+                }
+            }
+
+            return fl;
+        }
+    }
+
+    inline Opm::FlowDiagnostics::Toolbox
+    initialiseFlowDiagnostics(const Opm::ECLGraph& G)
+    {
+        const  Opm::FlowDiagnostics::ConnectivityGraph connGraph = 
+           Opm::FlowDiagnostics::ConnectivityGraph{ static_cast<int>(G.numCells()),
+                                                    G.neighbours() };
+
+        // Create the Toolbox.
+
+        Opm::FlowDiagnostics::Toolbox tool = Opm::FlowDiagnostics::Toolbox{ connGraph };
+
+        tool.assignPoreVolume(G.poreVolume());
+
+        Opm::FlowDiagnostics::ConnectionValues connectionsVals = Hack::convert_flux_to_SI(extractFluxField(G));
+        tool.assignConnectionFlux(connectionsVals);
+
+        Opm::ECLWellSolution wsol = Opm::ECLWellSolution{};
+
+        const std::vector<Opm::ECLWellSolution::WellData> well_fluxes =
+            wsol.solution(G.rawResultData(), G.numGrids());
+
+        tool.assignInflowFlux(extractWellFlows(G, well_fluxes));
+
+        return tool;
+    }
+
+  
+
+}
+
+
+

ApplicationCode/ReservoirDataModel/RigFlowDiagResultAddress.h

@@ -0,0 +1,56 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016-     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.
+//
+/////////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include <string>
+#include <set>
+
+#define RIG_FLD_TOF_RESNAME                  "TOF"
+#define RIG_FLD_CELL_FRACTION_RESNAME        "Fraction"
+#define RIG_FLD_MAX_FRACTION_TRACER_RESNAME  "MaxFractionTracer"
+#define RIG_FLD_COMMUNICATION_RESNAME        "Communication"
+
+class RigFlowDiagResultAddress
+{
+
+public:
+    RigFlowDiagResultAddress(const std::string& aVariableName, const std::set<std::string>& someSelectedTracerNames) 
+    : variableName(aVariableName), selectedTracerNames(someSelectedTracerNames) {}
+
+    RigFlowDiagResultAddress(const std::string& aVariableName, const std::string& tracerName)
+    : variableName(aVariableName)
+    {
+        selectedTracerNames.insert(tracerName);
+    }
+
+    bool isNativeResult() { return ( ( (variableName == RIG_FLD_TOF_RESNAME) || (variableName == RIG_FLD_CELL_FRACTION_RESNAME) ) && selectedTracerNames.size() <= 1); }
+
+    std::string           variableName;
+    std::set<std::string> selectedTracerNames;
+
+    bool operator< (const RigFlowDiagResultAddress& other) const
+    {
+        if ( selectedTracerNames != other.selectedTracerNames )
+        {
+            return selectedTracerNames < other.selectedTracerNames;
+        }
+
+        return variableName < other.variableName;
+    }
+};
+

ApplicationCode/ReservoirDataModel/RigFlowDiagResultFrames.cpp

@@ -0,0 +1,64 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2015-     Statoil ASA
+//  Copyright (C) 2015-     Ceetron Solutions AS
+// 
+//  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 <stdlib.h>
+
+#include "RigFlowDiagResultFrames.h"
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagResultFrames::RigFlowDiagResultFrames(size_t frameCount)
+{
+    m_dataForEachFrame.resize(frameCount);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagResultFrames::~RigFlowDiagResultFrames()
+{
+
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+size_t RigFlowDiagResultFrames::frameCount() const
+{
+    return m_dataForEachFrame.size();
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<double>& RigFlowDiagResultFrames::frameData(size_t frameIndex)
+{
+    return m_dataForEachFrame[frameIndex];
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<double>& RigFlowDiagResultFrames::frameData(size_t frameIndex) const
+{
+    return m_dataForEachFrame[frameIndex];
+}

ApplicationCode/ReservoirDataModel/RigFlowDiagResultFrames.h

@@ -0,0 +1,41 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016-     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.
+//
+/////////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include "cvfBase.h"
+#include "cvfObject.h"
+
+#include <vector>
+
+class RigFlowDiagResultFrames: public cvf::Object
+{
+public:
+    RigFlowDiagResultFrames(size_t frameCount);
+    virtual ~RigFlowDiagResultFrames();
+
+    const
+    std::vector<double>& frameData(size_t frameIndex) const;
+    std::vector<double>& frameData(size_t frameIndex);
+    size_t               frameCount() const;
+
+private:
+    std::vector< std::vector<double> > m_dataForEachFrame;
+};
+
+
+

ApplicationCode/ReservoirDataModel/RigFlowDiagResults.cpp

@@ -0,0 +1,298 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016-     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 "RigFlowDiagResults.h"
+#include "RigFlowDiagSolverInterface.h"
+#include "RimFlowDiagSolution.h"
+#include "RimEclipseResultCase.h"
+#include "RimEclipseCase.h"
+#include "RigCaseData.h"
+#include "RigFlowDiagStatCalc.h"
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagResults::RigFlowDiagResults(RimFlowDiagSolution* flowSolution, size_t timeStepCount)
+ : m_flowDiagSolution(flowSolution)
+{
+
+    m_timeStepCount = timeStepCount;
+    m_hasAtemptedNativeResults.resize(timeStepCount, false);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagResults::~RigFlowDiagResults()
+{
+
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<double>* RigFlowDiagResults::resultValues(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex)
+{
+    CVF_ASSERT(m_timeStepCount != cvf::UNDEFINED_SIZE_T); // Forgotten to call init
+
+    return findOrCalculateResult(resVarAddr, frameIndex);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const RigActiveCellInfo * RigFlowDiagResults::activeCellInfo(const RigFlowDiagResultAddress& resVarAddr)
+{
+    RimEclipseResultCase* eclCase;
+    m_flowDiagSolution->firstAncestorOrThisOfType(eclCase);
+    
+    return eclCase->reservoirData()->activeCellInfo(RifReaderInterface::MATRIX_RESULTS); // Todo: base on resVarAddr member
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<double>* RigFlowDiagResults::findOrCalculateResult(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex)
+{
+   
+    std::vector<double>* frameData = findScalarResultFrame(resVarAddr, frameIndex);
+
+    if ( frameData ) return frameData;
+
+    frameData = calculateDerivedResult(resVarAddr, frameIndex);
+
+    if ( frameData ) return frameData;
+
+    // We need to access the native data from the opm solver
+
+    if (!m_hasAtemptedNativeResults[frameIndex])
+    {
+        
+        RigFlowDiagTimeStepResult nativeTimestepResults =  solverInterface()->calculate(frameIndex, 
+                                                                                        m_flowDiagSolution->allInjectorTracerActiveCellIndices(frameIndex),
+                                                                                        m_flowDiagSolution->allProducerTracerActiveCellIndices(frameIndex));
+
+        std::map<RigFlowDiagResultAddress, std::vector<double> >& nativeResults = nativeTimestepResults.nativeResults();
+
+        for ( auto& resIt: nativeResults )
+        {
+            RigFlowDiagResultFrames*  nativeResFrames = findScalarResult(resIt.first);
+            if ( !nativeResFrames ) nativeResFrames = createScalarResult(resIt.first);
+
+            nativeResFrames->frameData(frameIndex).swap(resIt.second);
+        }
+
+        m_hasAtemptedNativeResults[frameIndex] = true;
+    }
+
+    return findScalarResultFrame(resVarAddr, frameIndex);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<double>* RigFlowDiagResults::findScalarResultFrame(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex)
+{
+    RigFlowDiagResultFrames*  resFrames = findScalarResult  (resVarAddr);
+
+    if ( resFrames )
+    {
+        std::vector<double>& frame = resFrames->frameData(frameIndex);
+        if ( frame.size() ) return(&frame);
+    }
+    return nullptr;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagSolverInterface* RigFlowDiagResults::solverInterface()
+{
+    RimEclipseResultCase* eclCase;
+    m_flowDiagSolution->firstAncestorOrThisOfType(eclCase);
+
+    return eclCase->flowDiagSolverInterface();
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagResultFrames* RigFlowDiagResults::createScalarResult(const RigFlowDiagResultAddress& resVarAddr)
+{
+    cvf::ref<RigFlowDiagResultFrames> newFrameSet = new RigFlowDiagResultFrames(m_timeStepCount);
+    m_resultSets[resVarAddr] = newFrameSet;
+
+    return newFrameSet.p();
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagResultFrames* RigFlowDiagResults::findScalarResult(const RigFlowDiagResultAddress& resVarAddr)
+{
+    decltype(m_resultSets)::iterator it = m_resultSets.find(resVarAddr);
+
+    if ( it == m_resultSets.end() ) return nullptr;
+
+    return it->second.p();
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<double>* RigFlowDiagResults::calculateDerivedResult(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex)
+{
+    return nullptr; // Todo
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigStatisticsDataCache* RigFlowDiagResults::statistics(const RigFlowDiagResultAddress& resVarAddr)
+{
+    RigStatisticsDataCache* statCache = m_resultStatistics[resVarAddr].p();
+    if ( !statCache )
+    {
+        RigFlowDiagStatCalc* calculator = new RigFlowDiagStatCalc(this, resVarAddr);
+        statCache = new RigStatisticsDataCache(calculator);
+        m_resultStatistics[resVarAddr] = statCache;
+    }
+
+    return statCache;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagResults::minMaxScalarValues(const RigFlowDiagResultAddress& resVarAddr, int frameIndex,
+                                                     double* localMin, double* localMax)
+{
+    this->statistics(resVarAddr)->minMaxCellScalarValues(frameIndex, *localMin, *localMax);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagResults::minMaxScalarValues(const RigFlowDiagResultAddress& resVarAddr,
+                                                     double* globalMin, double* globalMax)
+{
+    this->statistics(resVarAddr)->minMaxCellScalarValues(*globalMin, *globalMax);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagResults::posNegClosestToZero(const RigFlowDiagResultAddress& resVarAddr, int frameIndex, double* localPosClosestToZero, double* localNegClosestToZero)
+{
+    this->statistics(resVarAddr)->posNegClosestToZero(frameIndex, *localPosClosestToZero, *localNegClosestToZero);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagResults::posNegClosestToZero(const RigFlowDiagResultAddress& resVarAddr, double* globalPosClosestToZero, double* globalNegClosestToZero)
+{
+    this->statistics(resVarAddr)->posNegClosestToZero(*globalPosClosestToZero, *globalNegClosestToZero);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagResults::meanScalarValue(const RigFlowDiagResultAddress& resVarAddr, double* meanValue)
+{
+    CVF_ASSERT(meanValue);
+
+    this->statistics(resVarAddr)->meanCellScalarValues(*meanValue);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagResults::meanScalarValue(const RigFlowDiagResultAddress& resVarAddr, int frameIndex, double* meanValue)
+{
+    this->statistics(resVarAddr)->meanCellScalarValues(frameIndex, *meanValue);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagResults::p10p90ScalarValues(const RigFlowDiagResultAddress& resVarAddr, double* p10, double* p90)
+{
+    this->statistics(resVarAddr)->p10p90CellScalarValues(*p10, *p90);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagResults::p10p90ScalarValues(const RigFlowDiagResultAddress& resVarAddr, int frameIndex, double* p10, double* p90)
+{
+    this->statistics(resVarAddr)->p10p90CellScalarValues(frameIndex, *p10, *p90);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagResults::sumScalarValue(const RigFlowDiagResultAddress& resVarAddr, double* sum)
+{
+    CVF_ASSERT(sum);
+
+    this->statistics(resVarAddr)->sumCellScalarValues(*sum);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagResults::sumScalarValue(const RigFlowDiagResultAddress& resVarAddr, int frameIndex, double* sum)
+{
+    CVF_ASSERT(sum);
+
+    this->statistics(resVarAddr)->sumCellScalarValues(frameIndex, *sum);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<size_t>& RigFlowDiagResults::scalarValuesHistogram(const RigFlowDiagResultAddress& resVarAddr)
+{
+    return this->statistics(resVarAddr)->cellScalarValuesHistogram();
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<size_t>& RigFlowDiagResults::scalarValuesHistogram(const RigFlowDiagResultAddress& resVarAddr, int frameIndex)
+{
+    return this->statistics(resVarAddr)->cellScalarValuesHistogram(frameIndex);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<int>& RigFlowDiagResults::uniqueCellScalarValues(const RigFlowDiagResultAddress& resVarAddr)
+{
+    return this->statistics(resVarAddr)->uniqueCellScalarValues();
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<int>& RigFlowDiagResults::uniqueCellScalarValues(const RigFlowDiagResultAddress& resVarAddr, int frameIndex)
+{
+    return this->statistics(resVarAddr)->uniqueCellScalarValues(frameIndex);
+}

ApplicationCode/ReservoirDataModel/RigFlowDiagResults.h

@@ -0,0 +1,91 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016-     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.
+//
+/////////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include "RigFlowDiagResultAddress.h"
+
+#include "cvfBase.h"
+#include "cvfObject.h"
+
+#include <vector>
+#include <map>
+#include <string>
+
+#include "RigFlowDiagResultFrames.h"
+#include "RigStatisticsDataCache.h"
+#include "cafPdmPointer.h"
+
+class RigFlowDiagSolverInterface;
+class RimFlowDiagSolution;
+class RigActiveCellInfo;
+
+class RigFlowDiagResults: public cvf::Object
+{
+public:
+    RigFlowDiagResults(RimFlowDiagSolution* flowSolution, size_t timeStepCount);
+    virtual ~RigFlowDiagResults();
+
+    const std::vector<double>* resultValues(const RigFlowDiagResultAddress& resVarAddr,  size_t frameIndex);
+    size_t                     timeStepCount() { return m_timeStepCount; }
+    const RigActiveCellInfo *  activeCellInfo(const RigFlowDiagResultAddress& resVarAddr);
+
+
+    void                                             minMaxScalarValues (const RigFlowDiagResultAddress& resVarAddr, int frameIndex, double* localMin, double* localMax);
+    void                                             minMaxScalarValues (const RigFlowDiagResultAddress& resVarAddr, double* globalMin, double* globalMax);
+    void                                             posNegClosestToZero(const RigFlowDiagResultAddress& resVarAddr, int frameIndex, double* localPosClosestToZero, double* localNegClosestToZero);
+    void                                             posNegClosestToZero(const RigFlowDiagResultAddress& resVarAddr, double* globalPosClosestToZero, double* globalNegClosestToZero);
+    void                                             meanScalarValue(const RigFlowDiagResultAddress& resVarAddr, double* meanValue);
+    void                                             meanScalarValue(const RigFlowDiagResultAddress& resVarAddr, int frameIndex, double* meanValue);
+    void                                             p10p90ScalarValues(const RigFlowDiagResultAddress& resVarAddr, double* p10, double* p90);
+    void                                             p10p90ScalarValues(const RigFlowDiagResultAddress& resVarAddr, int frameIndex, double* p10, double* p90);
+    void                                             sumScalarValue(const RigFlowDiagResultAddress& resVarAddr, double* sum);
+    void                                             sumScalarValue(const RigFlowDiagResultAddress& resVarAddr, int frameIndex, double* sum);
+    const std::vector<size_t>&                       scalarValuesHistogram(const RigFlowDiagResultAddress& resVarAddr);
+    const std::vector<size_t>&                       scalarValuesHistogram(const RigFlowDiagResultAddress& resVarAddr, int frameIndex);
+    const std::vector<int>&                          uniqueCellScalarValues(const RigFlowDiagResultAddress& resVarAddr);
+    const std::vector<int>&                          uniqueCellScalarValues(const RigFlowDiagResultAddress& resVarAddr, int frameIndex);
+
+private:
+    const std::vector<double>* findOrCalculateResult (const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex);
+    std::vector<double>*       calculateDerivedResult(const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex);
+    RigStatisticsDataCache*    statistics(const RigFlowDiagResultAddress& resVarAddr);
+
+    void                       calculateFractionWeightedTOF  (size_t timeStepIdx, std::set<std::string> selectedTracerNames);
+    void                       calculateSumOfFractions       ( size_t timeStepIdx, std::set<std::string> selectedTracerNames);
+    void                       calculateTracerWithMaxFraction( size_t timeStepIdx, std::set<std::string> selectedTracerNames); // Needs a tracer index
+    void                       calculateCommunication        ( size_t timeStepIdx, std::set<std::string> selectedTracerNames);
+                               
+    RigFlowDiagResultFrames*   createScalarResult(const RigFlowDiagResultAddress& resVarAddr);
+    RigFlowDiagResultFrames*   findScalarResult  (const RigFlowDiagResultAddress& resVarAddr) ;
+    std::vector<double>*       findScalarResultFrame  (const RigFlowDiagResultAddress& resVarAddr, size_t frameIndex);
+
+    //void                       deleteScalarResult(const RigFlowDiagResultAddress& resVarAddr);
+
+    size_t m_timeStepCount;
+
+    std::map< RigFlowDiagResultAddress, cvf::ref<RigFlowDiagResultFrames> >  m_resultSets;
+    std::map< RigFlowDiagResultAddress, cvf::ref<RigStatisticsDataCache>  >  m_resultStatistics;
+
+    RigFlowDiagSolverInterface* solverInterface();
+
+    caf::PdmPointer<RimFlowDiagSolution> m_flowDiagSolution;
+
+    std::vector<bool> m_hasAtemptedNativeResults;
+};
+
+

ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp

@@ -0,0 +1,212 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016-     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 "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 <QMessageBox>
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagTimeStepResult::RigFlowDiagTimeStepResult(size_t activeCellCount)
+    : m_activeCellCount(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)
+{
+    std::set<std::string> tracers;
+    tracers.insert(tracerName);
+
+    this->addResult(RigFlowDiagResultAddress(RIG_FLD_CELL_FRACTION_RESNAME, tracers), cellValues);
+
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+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)
+{
+    std::set<std::string> tracers;
+    tracers.insert(tracerName);
+
+    this->addResult(RigFlowDiagResultAddress(RIG_FLD_CELL_FRACTION_RESNAME, tracers), cellValues);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagTimeStepResult::addResult(const RigFlowDiagResultAddress& resAddr, const std::map<int, double>& cellValues)
+{
+    std::vector<double>& activeCellValues =  m_nativeResults[resAddr];
+    activeCellValues.resize(m_activeCellCount, HUGE_VAL);
+
+    for (const auto& pairIt : cellValues)
+    {
+        activeCellValues[pairIt.first]  = pairIt.second;
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagSolverInterface::RigFlowDiagSolverInterface(RimEclipseResultCase * eclipseCase)
+: m_eclipseCase(eclipseCase)
+{
+    
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagSolverInterface::~RigFlowDiagSolverInterface()
+{
+
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagTimeStepResult RigFlowDiagSolverInterface::calculate(size_t timeStepIndex,
+                                                                std::map<std::string, std::vector<int> > injectorTracers,
+                                                                std::map<std::string, std::vector<int> > producerTracers)
+{
+    using namespace Opm::FlowDiagnostics;
+
+    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() )
+    {
+        // Look for set of restart files (one file per time step)
+
+        QStringList restartFileNames;
+        restartFileNames = RifEclipseOutputFileTools::filterFileNamesOfType(m_filesWithSameBaseName, ECL_RESTART_FILE);
+
+        size_t restartFileCount = static_cast<size_t>(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;
+        }
+
+        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)];
+    }
+
+    graph.assignFluxDataSource(restartFileName.toStdString());
+
+    if ( ! graph.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;
+    }
+
+    {
+        Toolbox fdTool = RigFlowDiagInterfaceTools::initialiseFlowDiagnostics(graph);
+        {
+            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);
+            }
+        }
+
+        {
+            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);
+            }
+        }
+    }
+
+
+    return result; // Relying on implicit move constructor
+}
+

ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.h

@@ -0,0 +1,72 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2016-     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.
+//
+/////////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include "RigFlowDiagResultAddress.h"
+#include "cvfBase.h"
+#include "cvfObject.h"
+#include "cafPdmPointer.h"
+
+#include <string>
+#include <vector>
+#include <map>
+
+class RimEclipseResultCase;
+class RimFlowDiagSolution;
+
+
+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);
+
+    // Use to "steal" the data from this one using swap
+    std::map<RigFlowDiagResultAddress, std::vector<double> >&  nativeResults() { return m_nativeResults; }
+private:
+
+    void addResult(const RigFlowDiagResultAddress& resAddr, const std::map<int, double>& cellValues);
+
+    std::map<RigFlowDiagResultAddress, std::vector<double> > m_nativeResults;
+    size_t m_activeCellCount;
+};
+
+
+class RigCaseData;
+
+class RigFlowDiagSolverInterface : public cvf::Object
+{
+public:
+    RigFlowDiagSolverInterface(RimEclipseResultCase * eclipseCase);
+    virtual ~RigFlowDiagSolverInterface();
+
+    RigFlowDiagTimeStepResult calculate(size_t timestep,  
+                                        std::map<std::string, std::vector<int> > injectorTracers, 
+                                        std::map<std::string, std::vector<int> > producerTracers);
+
+private:
+    RimEclipseResultCase * m_eclipseCase;
+
+};
+
+
+

ApplicationCode/ReservoirDataModel/RigFlowDiagStatCalc.cpp

@@ -0,0 +1,107 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) Statoil ASA
+//  Copyright (C) Ceetron Solutions AS
+// 
+//  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 "RigFlowDiagStatCalc.h"
+#include "RigFlowDiagResults.h"
+
+#include <math.h>
+#include "RigStatisticsMath.h"
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagStatCalc::RigFlowDiagStatCalc(RigFlowDiagResults* flowDiagResults, const RigFlowDiagResultAddress& resVarAddr)
+: m_resVarAddr(resVarAddr)
+{
+    m_resultsData = flowDiagResults;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagStatCalc::minMaxCellScalarValues(size_t timeStepIndex, double& min, double& max)
+{
+    MinMaxAccumulator minMaxCalc(min, max);
+    const std::vector<double>* vals = m_resultsData->resultValues(m_resVarAddr, timeStepIndex);
+
+    if (vals) minMaxCalc.addData(*vals);
+
+    min = minMaxCalc.min;
+    max = minMaxCalc.max;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagStatCalc::posNegClosestToZero(size_t timeStepIndex, double& pos, double& neg)
+{
+    PosNegAccumulator posNegCalc(pos, neg);
+    const std::vector<double>* vals = m_resultsData->resultValues(m_resVarAddr, timeStepIndex);
+
+    if ( vals ) posNegCalc.addData(*vals);
+
+    pos = posNegCalc.pos;
+    neg = posNegCalc.neg;
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagStatCalc::valueSumAndSampleCount(size_t timeStepIndex, double& valueSum, size_t& sampleCount)
+{
+    SumCountAccumulator sumCountCalc(valueSum, sampleCount);
+    const std::vector<double>* vals = m_resultsData->resultValues(m_resVarAddr, timeStepIndex);
+
+    if ( vals ) sumCountCalc.addData(*vals);
+
+    valueSum    = sumCountCalc.valueSum;
+    sampleCount = sumCountCalc.sampleCount;
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagStatCalc::addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator)
+{
+    const std::vector<double>* vals = m_resultsData->resultValues(m_resVarAddr, timeStepIndex);
+
+    if ( vals ) histogramCalculator.addData(*vals);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagStatCalc::uniqueValues(size_t timeStepIndex, std::set<int>& uniqueValues)
+{
+    const std::vector<double>* vals = m_resultsData->resultValues(m_resVarAddr, timeStepIndex);
+
+    if ( vals ) for ( double val : (*vals) ) uniqueValues.insert(static_cast<int>(val));
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+size_t RigFlowDiagStatCalc::timeStepCount()
+{
+    return m_resultsData->timeStepCount();
+}
+
+

ApplicationCode/ReservoirDataModel/RigFlowDiagStatCalc.h

@@ -0,0 +1,50 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) Statoil ASA
+//  Copyright (C) Ceetron Solutions AS
+// 
+//  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 "RigStatisticsCalculator.h"
+#include "RigFlowDiagResultAddress.h"
+
+class RigHistogramCalculator;
+class RigFlowDiagResults;
+
+//==================================================================================================
+/// 
+//==================================================================================================
+
+class RigFlowDiagStatCalc : public RigStatisticsCalculator
+{
+public:
+    RigFlowDiagStatCalc(RigFlowDiagResults* femResultCollection, const RigFlowDiagResultAddress& resVarAddr);
+
+    virtual void    minMaxCellScalarValues(size_t timeStepIndex, double& min, double& max);
+    virtual void    posNegClosestToZero(size_t timeStepIndex, double& pos, double& neg);
+    virtual void    valueSumAndSampleCount(size_t timeStepIndex, double& valueSum, size_t& sampleCount);
+    virtual void    addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator);
+    virtual void    uniqueValues(size_t timeStepIndex, std::set<int>& values);
+    virtual size_t  timeStepCount();
+
+private:
+    RigFlowDiagResults*      m_resultsData;
+    RigFlowDiagResultAddress m_resVarAddr;
+};
+
+
+

ApplicationCode/ReservoirDataModel/RigFlowDiagVisibleCellsStatCalc.cpp

@@ -0,0 +1,99 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2015-     Statoil ASA
+//  Copyright (C) 2015-     Ceetron Solutions AS
+// 
+//  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 "RigFlowDiagVisibleCellsStatCalc.h"
+#include "RigActiveCellInfo.h"
+
+#include <math.h>
+#include "RigStatisticsMath.h"
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+RigFlowDiagVisibleCellsStatCalc::RigFlowDiagVisibleCellsStatCalc(RigFlowDiagResults* resultsData,
+                                                                   const RigFlowDiagResultAddress& resVarAddr, 
+                                                                   const cvf::UByteArray* cellVisibilities)
+: m_resultsData(resultsData), m_resVarAddr(resVarAddr), m_cellVisibilities(cellVisibilities)
+{
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagVisibleCellsStatCalc::minMaxCellScalarValues(size_t timeStepIndex, double& min, double& max)
+{
+    MinMaxAccumulator acc(min, max);
+    traverseElementNodes(acc, timeStepIndex);
+    min = acc.min;
+    max = acc.max;
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagVisibleCellsStatCalc::posNegClosestToZero(size_t timeStepIndex, double& pos, double& neg)
+{
+    PosNegAccumulator acc(pos, neg);
+    traverseElementNodes(acc, timeStepIndex);
+    pos = acc.pos;
+    neg = acc.neg;
+
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagVisibleCellsStatCalc::valueSumAndSampleCount(size_t timeStepIndex, double& valueSum, size_t& sampleCount)
+{
+    SumCountAccumulator acc(valueSum, sampleCount);
+    traverseElementNodes(acc, timeStepIndex);
+    valueSum = acc.valueSum;
+    sampleCount = acc.sampleCount;
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagVisibleCellsStatCalc::addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator)
+{
+    traverseElementNodes(histogramCalculator, timeStepIndex);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigFlowDiagVisibleCellsStatCalc::uniqueValues(size_t timeStepIndex, std::set<int>& values)
+{
+    UniqueValueAccumulator acc;
+    traverseElementNodes(acc, timeStepIndex);
+    values = acc.uniqueValues;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+size_t RigFlowDiagVisibleCellsStatCalc::timeStepCount()
+{
+    return m_resultsData->timeStepCount();
+}
+
+

ApplicationCode/ReservoirDataModel/RigFlowDiagVisibleCellsStatCalc.h

@@ -0,0 +1,79 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2015-     Statoil ASA
+//  Copyright (C) 2015-     Ceetron Solutions AS
+// 
+//  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 "RigStatisticsCalculator.h"
+#include "RigFlowDiagResultAddress.h"
+#include "RigFlowDiagResults.h"
+#include "RigActiveCellInfo.h"
+
+#include "cvfArray.h"
+
+class RigFlowDiagResults;
+class RigActiveCellInfo;
+
+class RigFlowDiagVisibleCellsStatCalc : public RigStatisticsCalculator
+{
+public:
+    RigFlowDiagVisibleCellsStatCalc(RigFlowDiagResults* resultsData, 
+                                     const RigFlowDiagResultAddress& resVarAddr, 
+                                     const cvf::UByteArray* cellVisibilities);
+
+    virtual void    minMaxCellScalarValues(size_t timeStepIndex, double& min, double& max);
+    virtual void    posNegClosestToZero(size_t timeStepIndex, double& pos, double& neg);
+    virtual void    valueSumAndSampleCount(size_t timeStepIndex, double& valueSum, size_t& sampleCount);
+    virtual void    addDataToHistogramCalculator(size_t timeStepIndex, RigHistogramCalculator& histogramCalculator);
+    virtual void    uniqueValues(size_t timeStepIndex, std::set<int>& values);
+    virtual size_t  timeStepCount();
+
+private:
+    RigFlowDiagResults*             m_resultsData;
+    RigFlowDiagResultAddress        m_resVarAddr;
+    cvf::cref<cvf::UByteArray>      m_cellVisibilities;
+
+    template <typename StatisticsAccumulator>
+    void traverseElementNodes(StatisticsAccumulator& accumulator, size_t timeStepIndex)
+    {
+        const std::vector<double>* values = m_resultsData->resultValues(m_resVarAddr, timeStepIndex);
+        if (!values) return;
+
+        const RigActiveCellInfo* actCellInfo = m_resultsData->activeCellInfo(m_resVarAddr);
+
+        size_t cellCount = actCellInfo->reservoirCellCount();
+
+        CVF_TIGHT_ASSERT(cellCount == m_cellVisibilities->size());
+
+        for ( size_t cIdx = 0; cIdx < cellCount; ++cIdx )
+        {
+            if ( !(*m_cellVisibilities)[cIdx] ) continue;
+
+            size_t cellResultIndex = actCellInfo->cellResultIndex(cIdx);
+
+            if ( cellResultIndex != cvf::UNDEFINED_SIZE_T ) accumulator.addValue((*values)[cellResultIndex]);
+        }
+    }
+
+};
+
+
+

ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.cpp

@@ -38,15 +38,17 @@
 #include "cvfObject.h"
 
 #include <math.h>
+#include "RimFlowDiagSolution.h"
+#include "RigFlowDiagResults.h"
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-cvf::ref<RigResultAccessor> RigResultAccessorFactory::createResultAccessor(RigCaseData* eclipseCase,
-    size_t gridIndex,
-    RifReaderInterface::PorosityModelResultType porosityModel,
-    size_t timeStepIndex,
-    const QString& uiResultName)
+cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromUiResultName(RigCaseData* eclipseCase,
+                                                                             size_t gridIndex,
+                                                                             RifReaderInterface::PorosityModelResultType porosityModel,
+                                                                             size_t timeStepIndex,
+                                                                             const QString& uiResultName)
 {
     CVF_ASSERT(gridIndex < eclipseCase->gridCount());
     CVF_ASSERT(eclipseCase);
@@ -61,9 +63,9 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createResultAccessor(RigCa
 
         cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor(grid);
 
-        cvf::ref<RigResultAccessor> xTransAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, "TRANX");
-        cvf::ref<RigResultAccessor> yTransAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, "TRANY");
-        cvf::ref<RigResultAccessor> zTransAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, "TRANZ");
+        cvf::ref<RigResultAccessor> xTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "TRANX");
+        cvf::ref<RigResultAccessor> yTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "TRANY");
+        cvf::ref<RigResultAccessor> zTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "TRANZ");
 
         cellFaceAccessObject->setTransResultAccessors(xTransAccessor.p(), yTransAccessor.p(), zTransAccessor.p());
 
@@ -75,12 +77,12 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createResultAccessor(RigCa
 
         cvf::ref<RigCombMultResultAccessor> cellFaceAccessObject = new RigCombMultResultAccessor(grid);
 
-        cvf::ref<RigResultAccessor> multXPos = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTX");
-        cvf::ref<RigResultAccessor> multXNeg = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTX-");
-        cvf::ref<RigResultAccessor> multYPos = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTY");
-        cvf::ref<RigResultAccessor> multYNeg = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTY-");
-        cvf::ref<RigResultAccessor> multZPos = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTZ");
-        cvf::ref<RigResultAccessor> multZNeg = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTZ-");
+        cvf::ref<RigResultAccessor> multXPos = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTX");
+        cvf::ref<RigResultAccessor> multXNeg = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTX-");
+        cvf::ref<RigResultAccessor> multYPos = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTY");
+        cvf::ref<RigResultAccessor> multYNeg = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTY-");
+        cvf::ref<RigResultAccessor> multZPos = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTZ");
+        cvf::ref<RigResultAccessor> multZNeg = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, "MULTZ-");
 
         cellFaceAccessObject->setMultResultAccessors(multXPos.p(), multXNeg.p(), multYPos.p(), multYNeg.p(), multZPos.p(), multZNeg.p());
 
@@ -92,9 +94,9 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createResultAccessor(RigCa
 
         cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor(grid);
 
-        cvf::ref<RigResultAccessor> xTransAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riTranXResultName());
-        cvf::ref<RigResultAccessor> yTransAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riTranYResultName());
-        cvf::ref<RigResultAccessor> zTransAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riTranZResultName());
+        cvf::ref<RigResultAccessor> xTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riTranXResultName());
+        cvf::ref<RigResultAccessor> yTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riTranYResultName());
+        cvf::ref<RigResultAccessor> zTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riTranZResultName());
 
         cellFaceAccessObject->setTransResultAccessors(xTransAccessor.p(), yTransAccessor.p(), zTransAccessor.p());
 
@@ -106,9 +108,9 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createResultAccessor(RigCa
 
         cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor(grid);
 
-        cvf::ref<RigResultAccessor> xRiMultAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riMultXResultName());
-        cvf::ref<RigResultAccessor> yRiMultAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riMultYResultName());
-        cvf::ref<RigResultAccessor> zRiMultAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riMultZResultName());
+        cvf::ref<RigResultAccessor> xRiMultAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riMultXResultName());
+        cvf::ref<RigResultAccessor> yRiMultAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riMultYResultName());
+        cvf::ref<RigResultAccessor> zRiMultAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riMultZResultName());
 
         cellFaceAccessObject->setTransResultAccessors(xRiMultAccessor.p(), yRiMultAccessor.p(), zRiMultAccessor.p());
 
@@ -120,27 +122,27 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createResultAccessor(RigCa
 
         cvf::ref<RigCombTransResultAccessor> cellFaceAccessObject = new RigCombTransResultAccessor(grid);
 
-        cvf::ref<RigResultAccessor> xRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riAreaNormTranXResultName());
-        cvf::ref<RigResultAccessor> yRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riAreaNormTranYResultName());
-        cvf::ref<RigResultAccessor> zRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riAreaNormTranZResultName());
+        cvf::ref<RigResultAccessor> xRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riAreaNormTranXResultName());
+        cvf::ref<RigResultAccessor> yRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riAreaNormTranYResultName());
+        cvf::ref<RigResultAccessor> zRiAreaNormTransAccessor = RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, RimDefines::riAreaNormTranZResultName());
 
         cellFaceAccessObject->setTransResultAccessors(xRiAreaNormTransAccessor.p(), yRiAreaNormTransAccessor.p(), zRiAreaNormTransAccessor.p());
 
         return cellFaceAccessObject;
     }
 
-    return RigResultAccessorFactory::createNativeResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, uiResultName);
+    return RigResultAccessorFactory::createNativeFromUiResultName(eclipseCase, gridIndex, porosityModel, timeStepIndex, uiResultName);
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-cvf::ref<RigResultAccessor> RigResultAccessorFactory::createResultAccessor(RigCaseData* eclipseCase,
-    size_t gridIndex,
-    RifReaderInterface::PorosityModelResultType porosityModel,
-    size_t timeStepIndex,
-    const QString& uiResultName,
-    RimDefines::ResultCatType resultType)
+cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromNameAndType(RigCaseData* eclipseCase,
+                                                                            size_t gridIndex,
+                                                                            RifReaderInterface::PorosityModelResultType porosityModel,
+                                                                            size_t timeStepIndex,
+                                                                            const QString& uiResultName,
+                                                                            RimDefines::ResultCatType resultType)
 {
     CVF_ASSERT(gridIndex < eclipseCase->gridCount());
     CVF_ASSERT(eclipseCase);
@@ -164,38 +166,59 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createResultAccessor(RigCa
         adjustedTimeStepIndex = 0;
     }
 
-    return createResultAccessor(eclipseCase, gridIndex, porosityModel, adjustedTimeStepIndex, scalarSetIndex);
+    return createFromResultIdx(eclipseCase, gridIndex, porosityModel, adjustedTimeStepIndex, scalarSetIndex);
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-cvf::ref<RigResultAccessor> RigResultAccessorFactory::createResultAccessor(RigCaseData* eclipseCase, size_t gridIndex, size_t timeStepIndex, RimEclipseResultDefinition* resultDefinition)
+cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultDefinition(RigCaseData* eclipseCase,
+                                                                                 size_t gridIndex,
+                                                                                 size_t timeStepIndex,
+                                                                                 RimEclipseResultDefinition* resultDefinition)
 {
     RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(resultDefinition->porosityModel());
 
-    size_t adjustedTimeStepIndex = timeStepIndex;
-    if (resultDefinition->hasStaticResult())
+    if (resultDefinition->resultType() != RimDefines::FLOW_DIAGNOSTICS)
     {
-        adjustedTimeStepIndex = 0;
-    }
 
-    return RigResultAccessorFactory::createResultAccessor(
-        eclipseCase, 
-        gridIndex,
-        porosityModel,
-        adjustedTimeStepIndex,
-        resultDefinition->resultVariable());
+        size_t adjustedTimeStepIndex = timeStepIndex;
+        if ( resultDefinition->hasStaticResult() )
+        {
+            adjustedTimeStepIndex = 0;
+        }
+
+        return RigResultAccessorFactory::createFromUiResultName(eclipseCase,
+                                                                gridIndex,
+                                                                porosityModel,
+                                                                adjustedTimeStepIndex,
+                                                                resultDefinition->resultVariable());
+    }
+    else
+    {
+        RimFlowDiagSolution* flowSol = resultDefinition->flowDiagSolution();
+        if (!flowSol) return new RigHugeValResultAccessor;;
+
+        const std::vector<double>* resultValues = flowSol->flowDiagResults()->resultValues( resultDefinition->flowDiagResAddress(), timeStepIndex);
+        if (!resultValues) return new RigHugeValResultAccessor;
+
+        RigGridBase* grid = eclipseCase->grid(gridIndex);
+        if ( !grid ) return new RigHugeValResultAccessor;
+
+        cvf::ref<RigResultAccessor> object = new RigActiveCellsResultAccessor(grid, resultValues, eclipseCase->activeCellInfo(porosityModel));
+
+        return object;
+    }
 }
 
 //--------------------------------------------------------------------------------------------------
 /// This function must be harmonized with RigResultModifierFactory::createResultModifier()
 //--------------------------------------------------------------------------------------------------
-cvf::ref<RigResultAccessor> RigResultAccessorFactory::createNativeResultAccessor(RigCaseData* eclipseCase,
-    size_t gridIndex,
-    RifReaderInterface::PorosityModelResultType porosityModel,
-    size_t timeStepIndex,
-    const QString& uiResultName)
+cvf::ref<RigResultAccessor> RigResultAccessorFactory::createNativeFromUiResultName(RigCaseData* eclipseCase,
+                                                                                   size_t gridIndex,
+                                                                                   RifReaderInterface::PorosityModelResultType porosityModel,
+                                                                                   size_t timeStepIndex,
+                                                                                   const QString& uiResultName)
 {
     CVF_ASSERT(gridIndex < eclipseCase->gridCount());
     CVF_ASSERT(eclipseCase);
@@ -213,19 +236,19 @@ cvf::ref<RigResultAccessor> RigResultAccessorFactory::createNativeResultAccessor
         return NULL;
     }
 
-    return createResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, scalarSetIndex);
+    return createFromResultIdx(eclipseCase, gridIndex, porosityModel, timeStepIndex, scalarSetIndex);
 }
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-cvf::ref<RigResultAccessor> RigResultAccessorFactory::createResultAccessor(RigCaseData* eclipseCase,
-    size_t gridIndex, 
-    RifReaderInterface::PorosityModelResultType porosityModel, 
-    size_t timeStepIndex, 
-    size_t resultIndex)
+cvf::ref<RigResultAccessor> RigResultAccessorFactory::createFromResultIdx(RigCaseData* eclipseCase,
+                                                                          size_t gridIndex,
+                                                                          RifReaderInterface::PorosityModelResultType porosityModel,
+                                                                          size_t timeStepIndex,
+                                                                          size_t resultIndex)
 {
-    if (resultIndex == cvf::UNDEFINED_SIZE_T)
+    if ( resultIndex == cvf::UNDEFINED_SIZE_T )
     {
         return new RigHugeValResultAccessor;
     }

ApplicationCode/ReservoirDataModel/RigResultAccessorFactory.h

@@ -33,40 +33,40 @@ class RigResultAccessorFactory
 {
 public:
     static cvf::ref<RigResultAccessor>
-        createResultAccessor(RigCaseData* eclipseCase,
-        size_t gridIndex,
-        size_t timeStepIndex,
-        RimEclipseResultDefinition* resultDefinition);
-
-    static cvf::ref<RigResultAccessor> 
-        createResultAccessor(RigCaseData* eclipseCase,
-        size_t gridIndex,
-        RifReaderInterface::PorosityModelResultType porosityModel,
-        size_t timeStepIndex,
-        const QString& uiResultName);
+        createFromResultDefinition(RigCaseData* eclipseCase,
+                                   size_t gridIndex,
+                                   size_t timeStepIndex,
+                                   RimEclipseResultDefinition* resultDefinition);
 
     static cvf::ref<RigResultAccessor>
-        createResultAccessor(RigCaseData* eclipseCase,
-        size_t gridIndex,
-        RifReaderInterface::PorosityModelResultType porosityModel,
-        size_t timeStepIndex,
-        const QString& uiResultName,
-        RimDefines::ResultCatType resultType);
+        createFromUiResultName(RigCaseData* eclipseCase,
+                               size_t gridIndex,
+                               RifReaderInterface::PorosityModelResultType porosityModel,
+                               size_t timeStepIndex,
+                               const QString& uiResultName);
 
     static cvf::ref<RigResultAccessor>
-        createResultAccessor(RigCaseData* eclipseCase,
-        size_t gridIndex,
-        RifReaderInterface::PorosityModelResultType porosityModel,
-        size_t timeStepIndex,
-        size_t resultIndex);
+        createFromNameAndType(RigCaseData* eclipseCase,
+                              size_t gridIndex,
+                              RifReaderInterface::PorosityModelResultType porosityModel,
+                              size_t timeStepIndex,
+                              const QString& uiResultName,
+                              RimDefines::ResultCatType resultType);
+
+    static cvf::ref<RigResultAccessor>
+        createFromResultIdx(RigCaseData* eclipseCase,
+                            size_t gridIndex,
+                            RifReaderInterface::PorosityModelResultType porosityModel,
+                            size_t timeStepIndex,
+                            size_t resultIndex);
 
 private:
-    static cvf::ref<RigResultAccessor> 
-        createNativeResultAccessor(RigCaseData* eclipseCase,
-                                        size_t gridIndex,
-                                        RifReaderInterface::PorosityModelResultType porosityModel,
-                                        size_t timeStepIndex,
-                                        const QString& resultName);
+    static cvf::ref<RigResultAccessor>
+        createNativeFromUiResultName(RigCaseData* eclipseCase,
+                                     size_t gridIndex,
+                                     RifReaderInterface::PorosityModelResultType porosityModel,
+                                     size_t timeStepIndex,
+                                     const QString& resultName);
 
 };
 

ApplicationCode/ReservoirDataModel/RigResultModifierFactory.cpp

@@ -30,10 +30,10 @@
 /// This function must be harmonized with RigResultAccessorFactory::createNativeResultAccessor()
 //--------------------------------------------------------------------------------------------------
 cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigCaseData* eclipseCase,
-    size_t gridIndex,
-    RifReaderInterface::PorosityModelResultType porosityModel,
-    size_t timeStepIndex,
-    QString& uiResultName)
+                                                                           size_t gridIndex,
+                                                                           RifReaderInterface::PorosityModelResultType porosityModel,
+                                                                           size_t timeStepIndex,
+                                                                           QString& uiResultName)
 {
     if (!eclipseCase) return NULL;
 
@@ -52,11 +52,11 @@ cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigCa
 /// 
 //--------------------------------------------------------------------------------------------------
 cvf::ref<RigResultModifier> RigResultModifierFactory::createResultModifier(RigCaseData* eclipseCase,
-    size_t gridIndex,
-    RifReaderInterface::PorosityModelResultType porosityModel,
-    size_t timeStepIndex, size_t scalarResultIndex)
+                                                                           size_t gridIndex,
+                                                                           RifReaderInterface::PorosityModelResultType porosityModel,
+                                                                           size_t timeStepIndex, size_t scalarResultIndex)
 {
-    if (!eclipseCase) return NULL;
+    if ( !eclipseCase ) return NULL;
 
     if (!eclipseCase->results(porosityModel) || !eclipseCase->activeCellInfo(porosityModel))
     {

ApplicationCode/ReservoirDataModel/RigResultModifierFactory.h

@@ -27,19 +27,19 @@ class RigResultModifier;
 class RigResultModifierFactory
 {
 public:
-    static cvf::ref<RigResultModifier> 
+    static cvf::ref<RigResultModifier>
         createResultModifier(RigCaseData* eclipseCase,
-        size_t gridIndex,
-        RifReaderInterface::PorosityModelResultType porosityModel,
-        size_t timeStepIndex,
-        QString& uiResultName);
+                             size_t gridIndex,
+                             RifReaderInterface::PorosityModelResultType porosityModel,
+                             size_t timeStepIndex,
+                             QString& uiResultName);
 
-    static cvf::ref<RigResultModifier> 
+    static cvf::ref<RigResultModifier>
         createResultModifier(RigCaseData* eclipseCase,
-        size_t gridIndex,
-        RifReaderInterface::PorosityModelResultType porosityModel,
-        size_t timeStepIndex,
-        size_t scalarResultIndex);
+                             size_t gridIndex,
+                             RifReaderInterface::PorosityModelResultType porosityModel,
+                             size_t timeStepIndex,
+                             size_t scalarResultIndex);
 };
 
 

ApplicationCode/ReservoirDataModel/RigTimeHistoryResultAccessor.cpp

@@ -104,7 +104,7 @@ void RigTimeHistoryResultAccessor::computeTimeHistoryData()
 
         for (size_t i = 0; i < timeStepCount; i++)
         {
-            cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createResultAccessor(m_eclipseCaseData, m_gridIndex, m_porosityModel, i, m_scalarResultIndex);
+            cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromResultIdx(m_eclipseCaseData, m_gridIndex, m_porosityModel, i, m_scalarResultIndex);
 
             m_timeHistoryValues.push_back(resultAccessor->cellScalar(m_cellIndex));
         }

ApplicationCode/ResultStatisticsCache/RigStatisticsDataCache.cpp

@@ -262,7 +262,17 @@ const std::vector<int>& RigStatisticsDataCache::uniqueCellScalarValues()
 {
     computeUniqueValuesIfNeeded();
 
-    return m_uniqueValues;
+    return m_statsAllTimesteps.m_uniqueValues;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+const std::vector<int>& RigStatisticsDataCache::uniqueCellScalarValues(size_t timeStepIndex)
+{
+    computeUniqueValuesIfNeeded(timeStepIndex);
+
+    return m_statsPrTs[timeStepIndex].m_uniqueValues;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -334,15 +344,31 @@ void RigStatisticsDataCache::computeHistogramStatisticsIfNeeded(size_t timeStepI
 //--------------------------------------------------------------------------------------------------
 void RigStatisticsDataCache::computeUniqueValuesIfNeeded()
 {
-    if (m_uniqueValues.size() == 0)
+    if (m_statsAllTimesteps.m_uniqueValues.size() == 0)
     {
         std::set<int> setValues;
-        m_statisticsCalculator->uniqueValues(0, setValues);
+        m_statisticsCalculator->uniqueValues(0, setValues); // This is a Hack ! Only using first timestep. Ok for Static eclipse results but beware !
 
         for (auto val : setValues)
         {
-            m_uniqueValues.push_back(val);
+            m_statsAllTimesteps.m_uniqueValues.push_back(val);
         }
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigStatisticsDataCache::computeUniqueValuesIfNeeded(size_t timeStepIndex)
+{
+    if ( m_statsPrTs[timeStepIndex].m_uniqueValues.size() == 0 )
+    {
+        std::set<int> setValues;
+        m_statisticsCalculator->uniqueValues(timeStepIndex, setValues);
+
+        for ( auto val : setValues )
+        {
+            m_statsPrTs[timeStepIndex].m_uniqueValues.push_back(val);
+        }
+    }
+}

ApplicationCode/ResultStatisticsCache/RigStatisticsDataCache.h

@@ -56,12 +56,14 @@ public:
     const std::vector<size_t>&              cellScalarValuesHistogram(size_t timeStepIndex);
 
     const std::vector<int>&                 uniqueCellScalarValues();
+    const std::vector<int>&                 uniqueCellScalarValues(size_t timeStepIndex);
 
 private:
     void                                    computeHistogramStatisticsIfNeeded();
     void                                    computeHistogramStatisticsIfNeeded(size_t timeStepIndex);
 
     void                                    computeUniqueValuesIfNeeded();
+    void                                    computeUniqueValuesIfNeeded(size_t timeStepIndex);
 
 private:
     struct StatisticsValues
@@ -100,11 +102,12 @@ private:
         bool                m_isValueSumCalculated;
 
         std::vector<size_t> m_histogram;
+        std::vector<int>    m_uniqueValues;
     };
 
     StatisticsValues                m_statsAllTimesteps;
     std::vector<StatisticsValues>   m_statsPrTs;
-    std::vector<int>                m_uniqueValues;
+    
 
     cvf::ref<RigStatisticsCalculator>       m_statisticsCalculator;
 };

ApplicationCode/ResultStatisticsCache/RigStatisticsMath.h

@@ -62,7 +62,24 @@ private:
 class MinMaxAccumulator
 {
 public:
-    MinMaxAccumulator(double initMin, double initMax): max(initMax), min(initMin) {}
+    MinMaxAccumulator(double initMin = -HUGE_VAL, double initMax = HUGE_VAL): max(initMax), min(initMin) {}
+    
+    void addData(const std::vector<double>& values)
+    {
+        for ( double val : values )
+        {
+            addValue(val);
+        }
+    }
+
+    void addData(const std::vector<float>& values)
+    {
+        for ( float val : values )
+        {
+            addValue(val);
+        }
+    }
+
     void addValue(double value)
     {
         if (value == HUGE_VAL) // TODO
@@ -89,7 +106,24 @@ public:
 class PosNegAccumulator
 {
 public:
-    PosNegAccumulator(double initPos, double initNeg): pos(initPos), neg(initNeg) {}
+    PosNegAccumulator(double initPos = HUGE_VAL, double initNeg = -HUGE_VAL): pos(initPos), neg(initNeg) {}
+
+    void addData(const std::vector<double>& values) 
+    {
+        for (double val : values)
+        {
+            addValue(val);
+        }
+    }
+
+    void addData(const std::vector<float>& values)
+    {
+        for ( float val : values )
+        {
+            addValue(val);
+        }
+    }
+
     void addValue(double value)
     {
         if (value == HUGE_VAL)
@@ -116,7 +150,23 @@ public:
 class SumCountAccumulator
 {
 public:
-    SumCountAccumulator(double initSum, size_t initCount): valueSum(initSum), sampleCount(initCount) {}
+    SumCountAccumulator(double initSum = 0.0, size_t initCount = 0): valueSum(initSum), sampleCount(initCount) {}
+
+    void addData(const std::vector<double>& values)
+    {
+        for ( double val : values )
+        {
+            addValue(val);
+        }
+    }
+
+    void addData(const std::vector<float>& values)
+    {
+        for ( float val : values )
+        {
+            addValue(val);
+        }
+    }
 
     void addValue(double value)
     {
@@ -140,6 +190,22 @@ public:
     UniqueValueAccumulator()
     {}
 
+    void addData(const std::vector<double>& values)
+    {
+        for ( double val : values )
+        {
+            addValue(val);
+        }
+    }
+
+    void addData(const std::vector<float>& values)
+    {
+        for ( float val : values )
+        {
+            addValue(val);
+        }
+    }
+
     void addValue(double value)
     {
         uniqueValues.insert(static_cast<int>(value));

ApplicationCode/SocketInterface/RiaPropertyDataCommands.cpp

@@ -320,7 +320,7 @@ public:
 
         for (size_t tsIdx = 0; tsIdx < timestepCount; tsIdx++)
         {
-            cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createResultAccessor(rimCase->reservoirData(), gridIdx, porosityModelEnum, requestedTimesteps[tsIdx], propertyName);
+            cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromUiResultName(rimCase->reservoirData(), gridIdx, porosityModelEnum, requestedTimesteps[tsIdx], propertyName);
 
             if (resultAccessor.isNull())
             {

ApplicationCode/UserInterface/RiuExportMultipleSnapshotsWidget.cpp

@@ -20,6 +20,8 @@
 
 #include "RiaApplication.h"
 
+#include "RicExportMultipleSnapshotsFeature.h"
+
 #include "RimCase.h"
 #include "RimMultiSnapshotDefinition.h"
 #include "RimProject.h"
@@ -40,6 +42,7 @@
 #include <QTableView>
 #include <QToolButton>
 #include <QWidget>
+#include <QHeaderView>
 
 
 //--------------------------------------------------------------------------------------------------
@@ -65,8 +68,9 @@ RiuExportMultipleSnapshotsWidget::RiuExportMultipleSnapshotsWidget(QWidget* pare
     connect(m_pdmTableView->tableView(), SIGNAL(customContextMenuRequested(QPoint)), SLOT(customMenuRequested(QPoint)));
 
     m_pdmTableView->setListField(&(project->multiSnapshotDefinitions()));
-    m_pdmTableView->tableView()->resizeRowsToContents();
-    m_pdmTableView->tableView()->resizeColumnsToContents();
+
+    QHeaderView* verticalHeader = m_pdmTableView->tableView()->verticalHeader();
+    verticalHeader->setResizeMode(QHeaderView::Interactive);
 
     // Set active child array to be able to use generic delete
     caf::SelectionManager::instance()->setActiveChildArrayFieldHandle(&(project->multiSnapshotDefinitions()));
@@ -82,13 +86,13 @@ RiuExportMultipleSnapshotsWidget::RiuExportMultipleSnapshotsWidget(QWidget* pare
         // Save images in snapshot catalog relative to project directory
         QString snapshotFolderName = RiaApplication::instance()->createAbsolutePathFromProjectRelativePath("snapshots");
 
-        m_lineEdit = new QLineEdit(snapshotFolderName);
+        m_exportFolderLineEdit = new QLineEdit(snapshotFolderName);
 
         QToolButton* button = new QToolButton;
         button->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred));
         button->setText(QLatin1String("..."));
 
-        layout->addWidget(m_lineEdit);
+        layout->addWidget(m_exportFolderLineEdit);
         layout->addWidget(button);
 
         connect(button, SIGNAL(clicked()), this, SLOT(folderSelectionClicked()));
@@ -145,7 +149,6 @@ void RiuExportMultipleSnapshotsWidget::customMenuRequested(QPoint pos)
     menu.exec(globalPos);
 }
 
-
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -158,32 +161,29 @@ void RiuExportMultipleSnapshotsWidget::deleteAllSnapshotItems()
     m_rimProject->multiSnapshotDefinitions.uiCapability()->updateConnectedEditors();
 }
 
-
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
 void RiuExportMultipleSnapshotsWidget::exportSnapshots()
 {
-    // TODO: wire up call of static method
-    // RicExportMultipleSnapshotsFeature::staticMethod()
+    RicExportMultipleSnapshotsFeature::exportMultipleSnapshots(m_exportFolderLineEdit->text(), m_rimProject);
 }
 
-
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
 void RiuExportMultipleSnapshotsWidget::folderSelectionClicked()
 {
-    QString defaultPath = m_lineEdit->text();
+    QString defaultPath = m_exportFolderLineEdit->text();
 
-    QString directoryPath = QFileDialog::getExistingDirectory(m_lineEdit,
+    QString directoryPath = QFileDialog::getExistingDirectory(m_exportFolderLineEdit,
         tr("Get existing directory"),
         defaultPath,
         QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
 
     if (!directoryPath.isEmpty())
     {
-        m_lineEdit->setText(directoryPath);
+        m_exportFolderLineEdit->setText(directoryPath);
     }
 }
 
@@ -196,60 +196,38 @@ void RiuExportMultipleSnapshotsWidget::addSnapshotItem()
 
     RimMultiSnapshotDefinition* multiSnapshot = new RimMultiSnapshotDefinition();
 
-
-    //Getting default value from last entered line: 
     if (m_rimProject->multiSnapshotDefinitions.size() > 0)
     {
+        //Getting default value from last entered line: 
         RimMultiSnapshotDefinition* other = m_rimProject->multiSnapshotDefinitions[m_rimProject->multiSnapshotDefinitions.size() - 1];
 
-        multiSnapshot->caseObject = other->caseObject();
         multiSnapshot->viewObject = other->viewObject();
         multiSnapshot->timeStepStart = other->timeStepStart();
         multiSnapshot->timeStepEnd = other->timeStepEnd();
-
-
-        // Variant using copy based on xml string
-//         QString copyOfOriginalObject = other->writeObjectToXmlString();
-//         multiSnapshot->readObjectFromXmlString(copyOfOriginalObject, caf::PdmDefaultObjectFactory::instance());
-
-
     }
-
     else
     {
         RimProject* proj = RiaApplication::instance()->project();
         std::vector<RimCase*> cases;
         proj->allCases(cases);
-        RimCase* CaseExample = nullptr;
-        RimView* ViewExample = nullptr;
 
         if (cases.size() > 0)
         {
-            CaseExample = cases.at(0);
-            multiSnapshot->caseObject = CaseExample;
+            RimCase* caseExample = cases.at(0);
  
             std::vector<RimView*> viewExamples;
-            viewExamples = CaseExample->views();
+            viewExamples = caseExample->views();
 
             if (viewExamples.size() > 0)
             {
-                ViewExample = viewExamples.at(0);
-                multiSnapshot->viewObject = ViewExample;
+                RimView* viewExample = viewExamples.at(0);
+                multiSnapshot->viewObject = viewExample;
+                multiSnapshot->timeStepStart = viewExample->currentTimeStep();
+                multiSnapshot->timeStepEnd = viewExample->currentTimeStep();
             }
         }
-
-
     }
 
-        
-
-
     m_rimProject->multiSnapshotDefinitions.push_back(multiSnapshot);
     m_rimProject->multiSnapshotDefinitions.uiCapability()->updateConnectedEditors();
-
-    if (m_rimProject->multiSnapshotDefinitions.size() == 1)
-    {
-        m_pdmTableView->tableView()->resizeRowsToContents();
-        m_pdmTableView->tableView()->resizeColumnsToContents();
-    }
 }

ApplicationCode/UserInterface/RiuExportMultipleSnapshotsWidget.h

@@ -47,5 +47,5 @@ private slots:
 private:
     RimProject*          m_rimProject;
     caf::PdmUiTableView* m_pdmTableView;
-    QLineEdit*           m_lineEdit;
+    QLineEdit*           m_exportFolderLineEdit;
 };

ApplicationCode/UserInterface/RiuResultTextBuilder.cpp

@@ -378,9 +378,9 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigCaseData* eclipseCase,
             size_t sgasScalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SGAS");
             size_t swatScalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SWAT");
 
-            cvf::ref<RigResultAccessor> dataAccessObjectX = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, soilScalarSetIndex);
-            cvf::ref<RigResultAccessor> dataAccessObjectY = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, sgasScalarSetIndex);
-            cvf::ref<RigResultAccessor> dataAccessObjectZ = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, swatScalarSetIndex);
+            cvf::ref<RigResultAccessor> dataAccessObjectX = RigResultAccessorFactory::createFromResultIdx(eclipseCase, gridIndex, porosityModel, timeStepIndex, soilScalarSetIndex);
+            cvf::ref<RigResultAccessor> dataAccessObjectY = RigResultAccessorFactory::createFromResultIdx(eclipseCase, gridIndex, porosityModel, timeStepIndex, sgasScalarSetIndex);
+            cvf::ref<RigResultAccessor> dataAccessObjectZ = RigResultAccessorFactory::createFromResultIdx(eclipseCase, gridIndex, porosityModel, timeStepIndex, swatScalarSetIndex);
 
             double scalarValue = 0.0;
 
@@ -406,7 +406,7 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigCaseData* eclipseCase,
         {
             if (resultColors->resultVariable().compare(RimDefines::combinedTransmissibilityResultName(), Qt::CaseInsensitive) == 0)
             {
-                cvf::ref<RigResultAccessor> transResultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedTransmissibilityResultName());
+                cvf::ref<RigResultAccessor> transResultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedTransmissibilityResultName());
                 {
                     double scalarValue = transResultAccessor->cellFaceScalar(cellIndex, cvf::StructGridInterface::POS_I);
                     resultInfoText->append(QString("Tran X : %1\n").arg(scalarValue));
@@ -420,7 +420,7 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigCaseData* eclipseCase,
             }
             else if (resultColors->resultVariable().compare(RimDefines::combinedMultResultName(), Qt::CaseInsensitive) == 0)
             {
-                cvf::ref<RigResultAccessor> multResultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedMultResultName());
+                cvf::ref<RigResultAccessor> multResultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedMultResultName());
                 {
                     double scalarValue = 0.0;
 
@@ -442,7 +442,7 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigCaseData* eclipseCase,
             }
             else if (resultColors->resultVariable().compare(RimDefines::combinedRiTranResultName(), Qt::CaseInsensitive) == 0)
             {
-                cvf::ref<RigResultAccessor> transResultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedRiTranResultName());
+                cvf::ref<RigResultAccessor> transResultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedRiTranResultName());
                 {
                     double scalarValue = transResultAccessor->cellFaceScalar(cellIndex, cvf::StructGridInterface::POS_I);
                     resultInfoText->append(QString("riTran X : %1\n").arg(scalarValue));
@@ -456,7 +456,7 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigCaseData* eclipseCase,
             }
             else if (resultColors->resultVariable().compare(RimDefines::combinedRiMultResultName(), Qt::CaseInsensitive) == 0)
             {
-                cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedRiMultResultName());
+                cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedRiMultResultName());
                 {
                     double scalarValue = resultAccessor->cellFaceScalar(cellIndex, cvf::StructGridInterface::POS_I);
                     resultInfoText->append(QString("riMult X : %1\n").arg(scalarValue));
@@ -470,7 +470,7 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigCaseData* eclipseCase,
             }
             else if (resultColors->resultVariable().compare(RimDefines::combinedRiAreaNormTranResultName(), Qt::CaseInsensitive) == 0)
             {
-                cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedRiAreaNormTranResultName());
+                cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCase, gridIndex, porosityModel, 0, RimDefines::combinedRiAreaNormTranResultName());
                 {
                     double scalarValue = resultAccessor->cellFaceScalar(cellIndex, cvf::StructGridInterface::POS_I);
                     resultInfoText->append(QString("riTransByArea X : %1\n").arg(scalarValue));
@@ -484,12 +484,12 @@ void RiuResultTextBuilder::appendTextFromResultColors(RigCaseData* eclipseCase,
             }
             else
             {
-                resultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, 0, resultColors->scalarResultIndex());
+                resultAccessor = RigResultAccessorFactory::createFromResultIdx(eclipseCase, gridIndex, porosityModel, 0, resultColors->scalarResultIndex());
             }
         }
         else
         {
-            resultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCase, gridIndex, porosityModel, timeStepIndex, resultColors->scalarResultIndex());
+            resultAccessor = RigResultAccessorFactory::createFromResultIdx(eclipseCase, gridIndex, porosityModel, timeStepIndex, resultColors->scalarResultIndex());
         }
 
         if (resultAccessor.notNull())
@@ -531,7 +531,7 @@ QString RiuResultTextBuilder::cellEdgeResultDetails()
             }
 
             RifReaderInterface::PorosityModelResultType porosityModel = RigCaseCellResultsData::convertFromProjectModelPorosityModel(m_reservoirView->cellResult()->porosityModel());
-            cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createResultAccessor(m_reservoirView->eclipseCase()->reservoirData(), m_gridIndex, porosityModel, adjustedTimeStep, resultIndex);
+            cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromResultIdx(m_reservoirView->eclipseCase()->reservoirData(), m_gridIndex, porosityModel, adjustedTimeStep, resultIndex);
             if (resultAccessor.notNull())
             {
                 double scalarValue = resultAccessor->cellScalar(m_cellIndex);
@@ -660,9 +660,9 @@ QString RiuResultTextBuilder::cellResultText(RimEclipseCellColors* resultColors)
                 size_t sgasScalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SGAS");
                 size_t swatScalarSetIndex = gridCellResults->findOrLoadScalarResult(RimDefines::DYNAMIC_NATIVE, "SWAT");
 
-                cvf::ref<RigResultAccessor> dataAccessObjectX = RigResultAccessorFactory::createResultAccessor(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, soilScalarSetIndex);
-                cvf::ref<RigResultAccessor> dataAccessObjectY = RigResultAccessorFactory::createResultAccessor(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, sgasScalarSetIndex);
-                cvf::ref<RigResultAccessor> dataAccessObjectZ = RigResultAccessorFactory::createResultAccessor(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, swatScalarSetIndex);
+                cvf::ref<RigResultAccessor> dataAccessObjectX = RigResultAccessorFactory::createFromResultIdx(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, soilScalarSetIndex);
+                cvf::ref<RigResultAccessor> dataAccessObjectY = RigResultAccessorFactory::createFromResultIdx(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, sgasScalarSetIndex);
+                cvf::ref<RigResultAccessor> dataAccessObjectZ = RigResultAccessorFactory::createFromResultIdx(eclipseCaseData, m_gridIndex, porosityModel, m_timeStepIndex, swatScalarSetIndex);
 
                 double scalarValue = 0.0;
 
@@ -687,7 +687,7 @@ QString RiuResultTextBuilder::cellResultText(RimEclipseCellColors* resultColors)
                 adjustedTimeStep = 0;
             }
             
-            cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createResultAccessor(eclipseCaseData, m_gridIndex, porosityModel, adjustedTimeStep, resultVar);
+            cvf::ref<RigResultAccessor> resultAccessor = RigResultAccessorFactory::createFromUiResultName(eclipseCaseData, m_gridIndex, porosityModel, adjustedTimeStep, resultVar);
             if (resultAccessor.notNull())
             {
                 double scalarValue = resultAccessor->cellFaceScalar(m_cellIndex, m_face);

ApplicationCode/UserInterface/RiuSelectionChangedHandler.cpp

@@ -103,7 +103,11 @@ void RiuSelectionChangedHandler::addCurveFromSelectionItem(const RiuEclipseSelec
 {
     RimEclipseView* eclipseView = eclipseSelectionItem->m_view.p();
 
-    if (eclipseView->cellResult()->hasDynamicResult() &&
+    if (eclipseView->cellResult()->resultType() == RimDefines::FLOW_DIAGNOSTICS)
+    {
+        // Todo
+    }
+    else if (eclipseView->cellResult()->hasDynamicResult() &&
         eclipseView->eclipseCase() &&
         eclipseView->eclipseCase()->reservoirData())
     {

ApplicationCode/UserInterface/RiuViewer.cpp

@@ -39,6 +39,7 @@
 
 #include "cafCategoryLegend.h"
 #include "cafCeetronPlusNavigation.h"
+#include "cafDisplayCoordTransform.h"
 #include "cafEffectGenerator.h"
 #include "cafFrameAnimationControl.h"
 
@@ -170,8 +171,9 @@ RiuViewer::RiuViewer(const QGLFormat& format, QWidget* parent)
     setContextMenuPolicy(Qt::PreventContextMenu);
 
     m_gridBoxGenerator = new RivGridBoxGenerator;
-}
 
+    m_cursorPositionDomainCoords = cvf::Vec3d::UNDEFINED;
+}
 
 //--------------------------------------------------------------------------------------------------
 /// 
@@ -408,6 +410,29 @@ void RiuViewer::paintOverlayItems(QPainter* painter)
         m_versionInfoLabel->render(painter, pos);
         yPos +=  size.height() + margin;
     }
+
+    if (!m_cursorPositionDomainCoords.isUndefined())
+    {
+        if (mainCamera())
+        {
+            cvf::ref<caf::DisplayCoordTransform> trans = m_rimView->displayCoordTransform();
+
+            cvf::Vec3d displayCoord = trans->transformToDisplayCoord(m_cursorPositionDomainCoords);
+
+            cvf::Vec3d screenCoords;
+            if (mainCamera()->project(displayCoord, &screenCoords))
+            {
+                int translatedMousePosY = height() - screenCoords.y();
+                QPoint centerPos(screenCoords.x(), translatedMousePosY);
+
+                // Draw a cross hair marker
+                int markerHalfLength = 6;
+
+                painter->drawLine(centerPos.x(), centerPos.y() - markerHalfLength, centerPos.x(), centerPos.y() + markerHalfLength);
+                painter->drawLine(centerPos.x() - markerHalfLength, centerPos.y(), centerPos.x() + markerHalfLength, centerPos.y());
+            }
+        }
+    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -658,6 +683,54 @@ void RiuViewer::resizeGL(int width, int height)
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RiuViewer::mouseMoveEvent(QMouseEvent* mouseEvent)
+{
+    if (m_rimView)
+    {
+        RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
+        if (viewLinker)
+        {
+            int translatedMousePosX = mouseEvent->pos().x();
+            int translatedMousePosY = height() - mouseEvent->pos().y();
+
+            cvf::Vec3d displayCoord(0, 0, 0);
+            if (mainCamera()->unproject(cvf::Vec3d(static_cast<double>(translatedMousePosX), static_cast<double>(translatedMousePosY), 0), &displayCoord))
+            {
+                if (m_cursorPositionDomainCoords != cvf::Vec3d::UNDEFINED)
+                {
+                    // Reset the extra cursor if the view currently is receiving mouse cursor events
+                    // Set undefined and redraw to remove the previously displayed cursor
+                    m_cursorPositionDomainCoords = cvf::Vec3d::UNDEFINED;
+
+                    update();
+                }
+
+                cvf::ref<caf::DisplayCoordTransform> trans = m_rimView->displayCoordTransform();
+                cvf::Vec3d domainCoord = trans->transformToDomainCoord(displayCoord);
+
+                viewLinker->updateCursorPosition(m_rimView, domainCoord);
+            }
+        }
+    }
+
+    caf::Viewer::mouseMoveEvent(mouseEvent);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RiuViewer::leaveEvent(QEvent *)
+{
+    if (m_rimView && m_rimView->assosiatedViewLinker())
+    {
+        RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
+        viewLinker->updateCursorPosition(m_rimView, cvf::Vec3d::UNDEFINED);
+    }
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -755,6 +828,19 @@ void RiuViewer::updateParallelProjectionSettings(RiuViewer* sourceViewer)
     this->updateParallelProjectionCameraPosFromPointOfInterestMove(poi);
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RiuViewer::setCursorPosition(const cvf::Vec3d& domainCoord)
+{
+    if (m_cursorPositionDomainCoords != domainCoord)
+    {
+        m_cursorPositionDomainCoords = domainCoord;
+
+        update();
+    }
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/UserInterface/RiuViewer.h

@@ -96,6 +96,8 @@ public:
 
     void            updateParallelProjectionSettings(RiuViewer* sourceViewer);
 
+    void            setCursorPosition(const cvf::Vec3d& domainCoord);
+
 public slots:
     virtual void    slotSetCurrentFrame(int frameIndex);
     virtual void    slotEndAnimation();
@@ -103,6 +105,8 @@ public slots:
 protected:
     virtual void    optimizeClippingPlanes();
     virtual void    resizeGL(int width, int height);
+    virtual void    mouseMoveEvent(QMouseEvent* e) override;
+    virtual void    leaveEvent(QEvent *) override;
 
 private:
     void            updateTextAndTickMarkColorForOverlayItems();
@@ -140,5 +144,7 @@ private:
     RiuViewerCommands*          m_viewerCommands;
 
     RivGridBoxGenerator*        m_gridBoxGenerator;
+
+    cvf::Vec3d                  m_cursorPositionDomainCoords;
 };
 

Fwk/AppFwk/cafUserInterface/cafPdmUiDefaultObjectEditor.cpp

@@ -425,6 +425,10 @@ caf::PdmUiFieldEditorHandle* PdmUiFieldEditorHelper::fieldEditorForField(PdmUiFi
         {
             fieldTypeName = caf::PdmUiComboBoxEditor::uiEditorTypeName();
         }
+        else if (fieldTypeName.indexOf("PdmPtrArrayField") != -1)
+        {
+            fieldTypeName = caf::PdmUiListEditor::uiEditorTypeName();
+        }
         else if (field->toUiBasedQVariant().type() != QVariant::List)
         {
             // Handle a single value field with valueOptions: Make a combobox

Fwk/AppFwk/cafUserInterface/cafPdmUiTableViewModel.cpp

@@ -119,6 +119,10 @@ QVariant PdmUiTableViewModel::headerData(int section, Qt::Orientation orientatio
                 return uiFieldHandle->uiName(m_currentConfigName);
             }
         }
+        else if (orientation == Qt::Vertical)
+        {
+            return section;
+        }
     }
 
     return QVariant();
@@ -188,6 +192,30 @@ QVariant PdmUiTableViewModel::data(const QModelIndex &index, int role /*= Qt::Di
     if (role == Qt::DisplayRole || role == Qt::EditRole)
     {
         PdmFieldHandle* fieldHandle = getField(index);
+        if (dynamic_cast<PdmPtrArrayFieldHandle*>(fieldHandle))
+        {
+            PdmPtrArrayFieldHandle* ptrArrayFieldHandle = dynamic_cast<PdmPtrArrayFieldHandle*>(fieldHandle);
+
+            QString displayText;
+
+            for (size_t i = 0; i < ptrArrayFieldHandle->size(); i++)
+            {
+                PdmObjectHandle* objHandle = ptrArrayFieldHandle->at(i);
+                if (objHandle && objHandle->uiCapability())
+                {
+                    PdmUiObjectHandle* uiObjHandle = objHandle->uiCapability();
+                    if (!displayText.isEmpty()) displayText += ", ";
+
+                    caf::PdmUiFieldHandle* uiFieldHandle = uiObjHandle->userDescriptionField()->uiCapability();
+                    if (uiFieldHandle)
+                    {
+                        displayText += uiFieldHandle->uiValue().toString();
+                    }
+                }
+            }
+
+            return displayText;
+        }
         PdmUiFieldHandle* uiFieldHandle = fieldHandle->uiCapability();
         if (uiFieldHandle)
         {

Fwk/AppFwk/cafUserInterface/cafPdmUiTableViewModel.h

@@ -82,8 +82,6 @@ public:
 
     void                    selectedUiItems(std::vector<PdmUiItem*>& objects);
 
-    PdmUiFieldEditorHandle* getEditor(const QModelIndex &index);
-    QWidget*                getEditorWidgetAndTransferOwnership(QWidget* parent, const QModelIndex &index);
     void                    notifyDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight);
 
     bool                    isRepresentingBoolean(const QModelIndex &index) const;
@@ -92,6 +90,10 @@ private:
     int                     getFieldIndex(PdmFieldHandle* field) const;
     void                    recreateTableItemEditors();
 
+    friend class PdmUiTableViewDelegate;
+    QWidget*                getEditorWidgetAndTransferOwnership(QWidget* parent, const QModelIndex &index);
+    PdmUiFieldEditorHandle* getEditor(const QModelIndex &index);
+
 private:
     PdmChildArrayFieldHandle*                   m_pdmList;
     QString                                     m_currentConfigName;