#3416 Implement side-by-side injector/producer selection with ordering and select all.

ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp

@@ -34,7 +34,6 @@
 #include "RimEclipsePropertyFilter.h"
 #include "RimEclipseResultCase.h"
 #include "RimEclipseView.h"
-#include "RimFlowDiagSolution.h"
 #include "RimGridTimeHistoryCurve.h"
 #include "RimIntersectionCollection.h"
 #include "RimPlotCurve.h"
@@ -81,8 +80,17 @@ RimEclipseResultDefinition::RimEclipseResultDefinition()
     CAF_PDM_InitFieldNoDefault(&m_flowSolution, "FlowDiagSolution", "Solution", "", "", "");
     m_flowSolution.uiCapability()->setUiHidden(true);
 
-    CAF_PDM_InitFieldNoDefault(&m_selectedTracers, "SelectedTracers", "Tracers", "", "", "");
+    // One single tracer list has been split into injectors and producers.
-    m_selectedTracers.uiCapability()->setUiHidden(true);
+    // The old list is defined as injectors and we'll have to move any producers in old projects.
+    CAF_PDM_InitFieldNoDefault(&m_selectedTracers_OBSOLETE, "SelectedTracers", "Tracers", "", "", "");
+    m_selectedTracers_OBSOLETE.uiCapability()->setUiHidden(true);
+
+    CAF_PDM_InitFieldNoDefault(&m_selectedInjectorTracers, "SelectedInjectorTracers", "Tracers", "", "", "");
+    m_selectedInjectorTracers.uiCapability()->setUiHidden(true);
+
+    CAF_PDM_InitFieldNoDefault(&m_selectedProducerTracers, "SelectedProducerTracers", "Tracers", "", "", "");
+    m_selectedProducerTracers.uiCapability()->setUiHidden(true);
+
 
     CAF_PDM_InitFieldNoDefault(&m_selectedSouringTracers, "SelectedSouringTracers", "Tracers", "", "", "");
     m_selectedSouringTracers.uiCapability()->setUiHidden(true);
@@ -111,11 +119,21 @@ RimEclipseResultDefinition::RimEclipseResultDefinition()
     m_flowSolutionUiField.xmlCapability()->setIOWritable(false);
     m_flowSolutionUiField.uiCapability()->setUiHidden(true); // For now since there are only one to choose from
  
-    CAF_PDM_InitFieldNoDefault(&m_selectedTracersUiField, "MSelectedTracers", " ", "", "", "");
+    CAF_PDM_InitField(&m_selectAllInjectorTracers, "MSelectAllInjectorTracers", false, "Injectors, All ", "", "", "");
-    m_selectedTracersUiField.xmlCapability()->setIOReadable(false);
+    CAF_PDM_InitFieldNoDefault(&m_selectedInjectorTracersUiField, "MSelectedInjectorTracers", "Injector Tracers", "", "", "");
-    m_selectedTracersUiField.xmlCapability()->setIOWritable(false);
+    m_selectedInjectorTracersUiField.xmlCapability()->setIOReadable(false);
-    m_selectedTracersUiField.uiCapability()->setUiEditorTypeName(caf::PdmUiListEditor::uiEditorTypeName());
+    m_selectedInjectorTracersUiField.xmlCapability()->setIOWritable(false);
- 
+    m_selectedInjectorTracersUiField.uiCapability()->setUiEditorTypeName(caf::PdmUiListEditor::uiEditorTypeName());
+    m_selectedInjectorTracersUiField.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
+
+    CAF_PDM_InitField(&m_selectAllProducerTracers, "MSelectAllProducerTracers", false, "Producers, All ", "", "", "");
+
+    CAF_PDM_InitFieldNoDefault(&m_selectedProducerTracersUiField, "MSelectedProducerTracers", "Producer Tracers", "", "", "");
+    m_selectedProducerTracersUiField.xmlCapability()->setIOReadable(false);
+    m_selectedProducerTracersUiField.xmlCapability()->setIOWritable(false);
+    m_selectedProducerTracersUiField.uiCapability()->setUiEditorTypeName(caf::PdmUiListEditor::uiEditorTypeName());
+    m_selectedProducerTracersUiField.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
+
     CAF_PDM_InitFieldNoDefault(&m_selectedSouringTracersUiField, "MSelectedSouringTracers", "Tracers", "", "", "");
     m_selectedSouringTracersUiField.xmlCapability()->setIOReadable(false);
     m_selectedSouringTracersUiField.xmlCapability()->setIOWritable(false);
@@ -141,7 +159,8 @@ void RimEclipseResultDefinition::simpleCopy(const RimEclipseResultDefinition* ot
     this->setPorosityModel(other->porosityModel());
     this->setResultType(other->resultType());
     this->setFlowSolution(other->m_flowSolution());
-    this->setSelectedTracers(other->m_selectedTracers());
+    this->setSelectedInjectorTracers(other->m_selectedInjectorTracers());
+    this->setSelectedProducerTracers(other->m_selectedProducerTracers());
     this->setSelectedSouringTracers(other->m_selectedSouringTracers());
     m_flowTracerSelectionMode = other->m_flowTracerSelectionMode();
     m_phaseSelection = other->m_phaseSelection;
@@ -194,13 +213,22 @@ void RimEclipseResultDefinition::fieldChangedByUi(const caf::PdmFieldHandle* cha
                 m_resultVariableUiField = resultVariable();
             }
 
-            if (isFlowDiagFieldsRelevant) m_selectedTracersUiField = m_selectedTracers();
+            if (isFlowDiagFieldsRelevant)
-            else                          m_selectedTracersUiField = std::vector<QString>();
+            {
+                m_selectedInjectorTracersUiField = m_selectedInjectorTracers();
+                m_selectedProducerTracersUiField = m_selectedProducerTracers();
+            }
+            else
+            {
+                m_selectedInjectorTracersUiField = std::vector<QString>();
+                m_selectedProducerTracersUiField = std::vector<QString>();
+            }
         }
         else
         {
             m_resultVariableUiField = "";
-            m_selectedTracersUiField = std::vector<QString>();
+            m_selectedInjectorTracersUiField = std::vector<QString>();
+            m_selectedProducerTracersUiField = std::vector<QString>();
         }
     }
 
@@ -213,7 +241,8 @@ void RimEclipseResultDefinition::fieldChangedByUi(const caf::PdmFieldHandle* cha
         if (m_resultTypeUiField() == RiaDefines::FLOW_DIAGNOSTICS)
         {
             m_flowSolution = m_flowSolutionUiField();
-            m_selectedTracers = m_selectedTracersUiField();
+            m_selectedInjectorTracers = m_selectedInjectorTracersUiField();
+            m_selectedProducerTracers = m_selectedProducerTracersUiField();
         }
         else if (m_resultTypeUiField() == RiaDefines::INJECTION_FLOODING)
         {
@@ -222,38 +251,27 @@ void RimEclipseResultDefinition::fieldChangedByUi(const caf::PdmFieldHandle* cha
         loadDataAndUpdate();
     }
 
-    if ( &m_selectedTracersUiField == changedField )
+    if (&m_selectAllInjectorTracers == changedField)
     {
-        m_flowSolution = m_flowSolutionUiField();
+        toggleAllTracersSelection(&m_selectAllInjectorTracers);
-
-        if (m_selectedTracersUiFieldFilter().isEmpty())
-        {
-            m_selectedTracers = m_selectedTracersUiField();
-        }
-        else
-        {
-            auto filteredTracerNames = tracerNamesMatchingFilter();
-
-            // Keep selected strings not part of currently visible selection items
-            std::vector<QString> newSelection;
-            for (auto selectedTracer : m_selectedTracers())
-            {
-                if (std::find(begin(filteredTracerNames), end(filteredTracerNames), selectedTracer) == end(filteredTracerNames))
-                {
-                    newSelection.push_back(selectedTracer);
-                }
-            }
-
-            for (auto selectedTracerUi : m_selectedTracersUiField())
-            {
-                newSelection.push_back(selectedTracerUi);
-            }
-
-            m_selectedTracers = newSelection;
-        }
-
-        loadDataAndUpdate();
     }
+    if (&m_selectAllProducerTracers == changedField)
+    {
+        toggleAllTracersSelection(&m_selectAllProducerTracers);
+    }
+
+    if ( &m_selectedInjectorTracersUiField == changedField )
+    {
+        changedTracerSelectionField(true);
+        m_selectAllInjectorTracers = false;
+    }
+
+    if (&m_selectedProducerTracersUiField == changedField)
+    {
+        changedTracerSelectionField(false);
+        m_selectAllProducerTracers = false;
+    }
+
 
     if (&m_selectedSouringTracersUiField == changedField)
     {
@@ -275,14 +293,26 @@ void RimEclipseResultDefinition::fieldChangedByUi(const caf::PdmFieldHandle* cha
         loadDataAndUpdate();
     }
 
+    // TODO: Fix this to deal with the injector producer fields
     if (&m_selectedTracersUiFieldFilter == changedField)
     {
-        auto visibleTracerNames = tracerNamesMatchingFilter();
+        updateSelectedTracersFromFilter();
+    }
 
+    updateAnyFieldHasChanged();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimEclipseResultDefinition::updateSelectedTracersFromFilter()
+{
+    auto visibleTracerNames = tracerNamesMatchingFilter();
+
+    {
         std::vector<QString> subSelection;
-
+        // Remove hidden items from selection in injector tracers
-        // Remove hidden items from selection
+        for (auto selectedTracer : m_selectedInjectorTracers())
-        for (auto selectedTracer : m_selectedTracers())
         {
             if (std::find(begin(visibleTracerNames), end(visibleTracerNames), selectedTracer) != end(visibleTracerNames))
             {
@@ -290,12 +320,65 @@ void RimEclipseResultDefinition::fieldChangedByUi(const caf::PdmFieldHandle* cha
             }
         }
 
-        m_selectedTracersUiField = subSelection;
+        m_selectedInjectorTracersUiField = subSelection;
-
-        updateConnectedEditors();
     }
 
-    updateAnyFieldHasChanged();
+    {
+        std::vector<QString> subSelection;
+        // Remove hidden items from selection in producer tracers
+        for (auto selectedTracer : m_selectedProducerTracers())
+        {
+            if (std::find(begin(visibleTracerNames), end(visibleTracerNames), selectedTracer) != end(visibleTracerNames))
+            {
+                subSelection.push_back(selectedTracer);
+            }
+        }
+
+        m_selectedProducerTracersUiField = subSelection;
+    }
+
+    updateConnectedEditors();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimEclipseResultDefinition::changedTracerSelectionField(bool injector)
+{
+    m_flowSolution = m_flowSolutionUiField();
+
+    std::vector<QString>& selectedTracers = injector ? m_selectedInjectorTracers.v()
+                                                     : m_selectedProducerTracers.v();
+    std::vector<QString>& selectedTracersUi = injector ? m_selectedInjectorTracersUiField.v()
+                                                       : m_selectedProducerTracersUiField.v();
+
+    if (m_selectedTracersUiFieldFilter().isEmpty())
+    {
+        selectedTracers = selectedTracersUi;
+    }
+    else
+    {
+        auto filteredTracerNames = tracerNamesMatchingFilter();
+
+        // Keep selected strings not part of currently visible selection items
+        std::vector<QString> newSelection;
+        for (auto selectedTracer : selectedTracers)
+        {
+            if (std::find(begin(filteredTracerNames), end(filteredTracerNames), selectedTracer) == end(filteredTracerNames))
+            {
+                newSelection.push_back(selectedTracer);
+            }
+        }
+
+        for (auto selectedTracerUi : selectedTracersUi)
+        {
+            newSelection.push_back(selectedTracerUi);
+        }
+
+        selectedTracers = newSelection;
+    }
+
+    loadDataAndUpdate();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -355,14 +438,26 @@ void RimEclipseResultDefinition::setTofAndSelectTracer(const QString& tracerName
     setResultVariable("TOF");
     setFlowDiagTracerSelectionType(FLOW_TR_BY_SELECTION);
 
-    std::vector<QString> tracers;
-    tracers.push_back(tracerName);
-    setSelectedTracers(tracers);
-
     if (m_flowSolution() == nullptr)
     {
         assignFlowSolutionFromCase();
     }
+
+    if (m_flowSolution())
+    {
+        RimFlowDiagSolution::TracerStatusType tracerStatus = m_flowSolution()->tracerStatusOverall(tracerName);
+
+        std::vector<QString> tracers;
+        tracers.push_back(tracerName);
+        if (tracerStatus == RimFlowDiagSolution::INJECTOR)
+        {
+            setSelectedInjectorTracers(tracers);
+        }
+        else if (tracerStatus == RimFlowDiagSolution::PRODUCER)
+        {
+            setSelectedProducerTracers(tracers);
+        }
+    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -546,33 +641,13 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calculateValueOptions(
                 }
             }           
         }
-        else if (fieldNeedingOptions == &m_selectedTracersUiField)
+        else if (fieldNeedingOptions == &m_selectedInjectorTracersUiField)
         {
-            RimFlowDiagSolution* flowSol = m_flowSolutionUiField();
+            options = calcOptionsForSelectedTracerField(true);
-            if (flowSol)
+        }
-            {
+        else if (fieldNeedingOptions == &m_selectedProducerTracersUiField)
-                std::vector<QString> tracerNames = tracerNamesMatchingFilter();
+        {
-                std::map<QString, QString> prefixedTracerNamesMap;
+            options = calcOptionsForSelectedTracerField(false);
-                for ( const QString& tracerName : tracerNames )
-                {
-                    RimFlowDiagSolution::TracerStatusType status = flowSol->tracerStatusOverall(tracerName);
-                    QString prefix; 
-                    switch ( status )
-                    {
-                        case RimFlowDiagSolution::INJECTOR: prefix = "I   : "; break;
-                        case RimFlowDiagSolution::PRODUCER: prefix = "P  : "; break;
-                        case RimFlowDiagSolution::VARYING:  prefix = "I/P: "; break;
-                        case RimFlowDiagSolution::UNDEFINED:prefix = "U  : "; break;
-                    }
-
-                    if (status != RimFlowDiagSolution::CLOSED) prefixedTracerNamesMap[prefix + tracerName] = tracerName;
-                }
-
-                for (auto nameIt: prefixedTracerNamesMap)
-                {
-                    options.push_back(caf::PdmOptionItemInfo(nameIt.first, QVariant(nameIt.second)));
-                }
-            }
         }
     }
     else if (m_resultTypeUiField() == RiaDefines::INJECTION_FLOODING)
@@ -614,7 +689,6 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calculateValueOptions(
     return options;
 }
 
-
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -710,6 +784,65 @@ QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calcOptionsForVariable
     return QList<caf::PdmOptionItemInfo>();
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+QList<caf::PdmOptionItemInfo> RimEclipseResultDefinition::calcOptionsForSelectedTracerField(bool injector)
+{
+    QList<caf::PdmOptionItemInfo> options;
+
+    RimFlowDiagSolution* flowSol = m_flowSolutionUiField();
+    if (flowSol)
+    {
+        std::vector<QString> tracerNames = tracerNamesMatchingFilter();
+        std::list<QString> sortedTracers;
+
+        for (const QString& tracerName : tracerNames)
+        {
+            RimFlowDiagSolution::TracerStatusType status = flowSol->tracerStatusOverall(tracerName);
+            bool includeTracer = status == RimFlowDiagSolution::VARYING || status == RimFlowDiagSolution::UNDEFINED;
+            includeTracer |= injector && status == RimFlowDiagSolution::INJECTOR;
+            includeTracer |= !injector && status == RimFlowDiagSolution::PRODUCER;
+
+            if (includeTracer)
+            {
+                auto it = std::upper_bound(sortedTracers.begin(), sortedTracers.end(), tracerName, 
+                    [](const QString& lhs, const QString& rhs)
+                {
+                    if (!lhs.endsWith("-XF") && rhs.endsWith("-XF"))
+                    {
+                        return true;
+                    }
+                    else if (lhs.endsWith("-XF") && !rhs.endsWith("-XF"))
+                    {
+                        return false;
+                    }
+                    else
+                    {
+                        return lhs < rhs;
+                    }
+                });
+                sortedTracers.insert(it, tracerName);
+            }
+        }
+        for (const QString& tracerName : sortedTracers)
+        {
+            QString postfix;
+            RimFlowDiagSolution::TracerStatusType status = flowSol->tracerStatusOverall(tracerName);
+            if (status == RimFlowDiagSolution::VARYING)
+            {
+                postfix = " [I/P]";
+            }
+            else if (status == RimFlowDiagSolution::UNDEFINED)
+            {
+                postfix = " [U]";
+            }
+            options.push_back(caf::PdmOptionItemInfo(tracerName + postfix, tracerName));
+        }
+    }
+    return options;
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -785,7 +918,11 @@ RigFlowDiagResultAddress RimEclipseResultDefinition::flowDiagResAddress() const
         std::set<std::string> selTracerNames;
         if (m_flowTracerSelectionMode == FLOW_TR_BY_SELECTION)
         {
-            for (const QString& tName : m_selectedTracers())
+            for (const QString& tName : m_selectedInjectorTracers())
+            {
+                selTracerNames.insert(tName.toStdString());
+            }
+            for (const QString& tName : m_selectedProducerTracers())
             {
                 selTracerNames.insert(tName.toStdString());
             }
@@ -1008,7 +1145,43 @@ void RimEclipseResultDefinition::initAfterRead()
     m_resultVariableUiField = m_resultVariable;
 
     m_flowSolutionUiField = m_flowSolution();
-    m_selectedTracersUiField = m_selectedTracers;
+    m_selectedInjectorTracersUiField = m_selectedInjectorTracers;
+
+    if (m_flowSolution() == nullptr)
+    {
+        assignFlowSolutionFromCase();
+    }
+
+    if (m_flowSolution())
+    {
+        std::vector<QString> selectedInjectorTracers;
+        std::vector<QString> selectedProducerTracers;
+        for (const QString& tracerName : m_selectedTracers_OBSOLETE())
+        {
+            RimFlowDiagSolution::TracerStatusType tracerStatus = m_flowSolution()->tracerStatusOverall(tracerName);
+            if (tracerStatus == RimFlowDiagSolution::INJECTOR)
+            {
+                selectedInjectorTracers.push_back(tracerName);
+            }
+            else if (tracerStatus == RimFlowDiagSolution::PRODUCER)
+            {
+                selectedProducerTracers.push_back(tracerName);
+            }            
+            else if (tracerStatus == RimFlowDiagSolution::VARYING || tracerStatus == RimFlowDiagSolution::UNDEFINED)
+            {
+                selectedInjectorTracers.push_back(tracerName);
+                selectedProducerTracers.push_back(tracerName);
+            }
+        }
+        if (!selectedInjectorTracers.empty())
+        {
+            setSelectedInjectorTracers(selectedInjectorTracers);
+        }
+        if (!selectedProducerTracers.empty())
+        {
+            setSelectedProducerTracers(selectedProducerTracers);
+        }
+    }
 
     this->updateUiIconFromToggleField();
 }
@@ -1058,12 +1231,56 @@ void RimEclipseResultDefinition::setFlowSolution(RimFlowDiagSolution* flowSol)
 }
 
 //--------------------------------------------------------------------------------------------------
-/// 
+///
 //--------------------------------------------------------------------------------------------------
 void RimEclipseResultDefinition::setSelectedTracers(const std::vector<QString>& selectedTracers)
 {
-    this->m_selectedTracers = selectedTracers;
+    if (m_flowSolution() == nullptr)
-    this->m_selectedTracersUiField = selectedTracers;
+    {
+        assignFlowSolutionFromCase();
+    }
+    if (m_flowSolution())
+    {
+        std::vector<QString> injectorTracers;
+        std::vector<QString> producerTracers;
+        for (const QString& tracerName : selectedTracers)
+        {
+            RimFlowDiagSolution::TracerStatusType tracerStatus = m_flowSolution()->tracerStatusOverall(tracerName);
+            if (tracerStatus == RimFlowDiagSolution::INJECTOR)
+            {
+                injectorTracers.push_back(tracerName);
+            }
+            else if (tracerStatus == RimFlowDiagSolution::PRODUCER)
+            {
+                producerTracers.push_back(tracerName);
+            }
+            else if (tracerStatus == RimFlowDiagSolution::VARYING || tracerStatus == RimFlowDiagSolution::UNDEFINED)
+            {
+                injectorTracers.push_back(tracerName);
+                producerTracers.push_back(tracerName);
+            }
+        }
+        setSelectedInjectorTracers(injectorTracers);
+        setSelectedProducerTracers(producerTracers);
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RimEclipseResultDefinition::setSelectedInjectorTracers(const std::vector<QString>& selectedTracers)
+{
+    this->m_selectedInjectorTracers = selectedTracers;
+    this->m_selectedInjectorTracersUiField = selectedTracers;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimEclipseResultDefinition::setSelectedProducerTracers(const std::vector<QString>& selectedTracers)
+{
+    this->m_selectedProducerTracers = selectedTracers;
+    this->m_selectedProducerTracersUiField = selectedTracers;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -1172,8 +1389,17 @@ void RimEclipseResultDefinition::defineUiOrdering(QString uiConfigName, caf::Pdm
         
         if (m_flowTracerSelectionMode == FLOW_TR_BY_SELECTION)
         {
-            uiOrdering.add(&m_selectedTracersUiFieldFilter);
+            caf::PdmUiGroup* selectionGroup = uiOrdering.addNewGroup("Tracer Selection");
-            uiOrdering.add(&m_selectedTracersUiField);
+            selectionGroup->setEnableFrame(false);
+            selectionGroup->add(&m_selectedTracersUiFieldFilter);
+            caf::PdmUiGroup* injectorGroup = selectionGroup->addNewGroup("Injectors");
+            injectorGroup->setEnableFrame(false);
+            injectorGroup->add(&m_selectAllInjectorTracers);            
+            injectorGroup->add(&m_selectedInjectorTracersUiField);
+            caf::PdmUiGroup* producerGroup = selectionGroup->addNewGroup("Producers", false);
+            producerGroup->setEnableFrame(false);
+            producerGroup->add(&m_selectAllProducerTracers);
+            producerGroup->add(&m_selectedProducerTracersUiField);
         }
 
         uiOrdering.add(&m_phaseSelection);
@@ -1265,3 +1491,29 @@ std::vector<QString> RimEclipseResultDefinition::tracerNamesMatchingFilter() con
     return matchingNames;
 }
 
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimEclipseResultDefinition::toggleAllTracersSelection(const caf::PdmField<bool>* changedField)
+{
+    bool injector = &m_selectAllInjectorTracers == changedField;
+    std::vector<QString> tracerNames;
+    if (changedField->v())
+    {
+        QList<caf::PdmOptionItemInfo> options = calcOptionsForSelectedTracerField(injector);
+
+        for (const caf::PdmOptionItemInfo& itemInfo : options)
+        {
+            tracerNames.push_back(itemInfo.value().toString());
+        }
+    }
+    if (injector)
+    {
+        setSelectedInjectorTracers(tracerNames);
+    }
+    else
+    {
+        setSelectedProducerTracers(tracerNames);
+    }
+}

ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.h

@@ -24,6 +24,7 @@
 #include "RiaPorosityModel.h"
 
 #include "RigFlowDiagResultAddress.h"
+#include "RimFlowDiagSolution.h"
 
 #include "cafAppEnum.h"
 #include "cafPdmField.h"
@@ -35,7 +36,6 @@ class RigCaseCellResultsData;
 class RimEclipseCase;
 class RimEclipseView;
 class RimReservoirCellResultsStorage;
-class RimFlowDiagSolution;
 
 
 //==================================================================================================
@@ -97,6 +97,8 @@ public:
 
     void                            setTofAndSelectTracer(const QString& tracerName);
     void                            setSelectedTracers(const std::vector<QString>& selectedTracers);
+    void                            setSelectedInjectorTracers(const std::vector<QString>& selectedTracers);
+    void                            setSelectedProducerTracers(const std::vector<QString>& selectedTracers);
     void                            setSelectedSouringTracers(const std::vector<QString>& selectedTracers);
 
     void                            updateUiFieldsFromActiveResult();
@@ -106,6 +108,7 @@ protected:
 
     virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly);
     virtual void                          fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue);
+
     virtual void                          initAfterRead();
     virtual void                          defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
     virtual void                          defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute) override;
@@ -115,9 +118,11 @@ protected:
     caf::PdmField< caf::AppEnum< RiaDefines::PorosityModelType > >  m_porosityModel;
     caf::PdmField<QString>                                          m_resultVariable;
 
-    caf::PdmPtrField<RimFlowDiagSolution*>                          m_flowSolution;
+    caf::PdmPtrField<RimFlowDiagSolution*>                          m_flowSolution;    
-    caf::PdmField<std::vector<QString> >                            m_selectedTracers;
+    caf::PdmField<bool>                                             m_selectAllInjectorTracers;
-
+    caf::PdmField<bool>                                             m_selectAllProducerTracers;
+    caf::PdmField<std::vector<QString> >                            m_selectedInjectorTracers;
+    caf::PdmField<std::vector<QString> >                            m_selectedProducerTracers;
     caf::PdmField<std::vector<QString> >                            m_selectedSouringTracers;
 
     friend class RimEclipsePropertyFilter;
@@ -135,22 +140,30 @@ protected:
     caf::PdmField< RigFlowDiagResultAddress::PhaseSelectionEnum >   m_phaseSelection;
     
     caf::PdmField<QString>                                          m_selectedTracersUiFieldFilter;
-    caf::PdmField<std::vector<QString> >                            m_selectedTracersUiField;
+    caf::PdmField<std::vector<QString> >                            m_selectedInjectorTracersUiField;
+    caf::PdmField<std::vector<QString> >                            m_selectedProducerTracersUiField;
 
     caf::PdmField<std::vector<QString> >                            m_selectedSouringTracersUiField;
 
 
     caf::PdmPointer<RimEclipseCase>                                 m_eclipseCase;
 
+    caf::PdmField<std::vector<QString> >                            m_selectedTracers_OBSOLETE;
+
 private:
     void                            assignFlowSolutionFromCase();
 
     bool                            hasDualPorFractureResult();
 
     QList<caf::PdmOptionItemInfo>   calcOptionsForVariableUiFieldStandard();
+    QList<caf::PdmOptionItemInfo>   calcOptionsForSelectedTracerField(bool injector);
+
+    void                            updateSelectedTracersFromFilter();
+    void                            changedTracerSelectionField(bool injector);
     QStringList                     getResultNamesForCurrentUiResultType();
     static void                     removePerCellFaceOptionItems(QList<caf::PdmOptionItemInfo>& optionItems);
 
     std::vector<QString>            tracerNamesMatchingFilter() const;
+    void                            toggleAllTracersSelection(const caf::PdmField<bool>* changedField);
 };