#1559 Use common export completions command for well paths and simulation wells

ApplicationCode/Commands/CompletionCommands/RicExportCompletionDataSettingsUi.cpp

@@ -40,6 +40,22 @@ RicExportCompletionDataSettingsUi::RicExportCompletionDataSettingsUi()
 
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicExportCompletionDataSettingsUi::showForSimWells()
+{
+    m_displayForSimWell = true;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicExportCompletionDataSettingsUi::showForWellPath()
+{
+    m_displayForSimWell = false;
+}
+
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
@@ -66,3 +82,25 @@ QList<caf::PdmOptionItemInfo> RicExportCompletionDataSettingsUi::calculateValueO
     }
     return options;
 }
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicExportCompletionDataSettingsUi::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
+{
+    uiOrdering.add(&fileName);
+    uiOrdering.add(&caseToApply);
+    uiOrdering.add(&timeStep);
+    uiOrdering.add(&computeTransmissibility);
+    uiOrdering.add(&includeWpimult);
+
+    if (!m_displayForSimWell)
+    {
+        uiOrdering.add(&includePerforations);
+        uiOrdering.add(&includeFishbones);
+        uiOrdering.add(&includeFractures);
+        uiOrdering.add(&removeLateralsInMainBoreCells);
+    }
+
+    uiOrdering.skipRemainingFields();
+}

ApplicationCode/Commands/CompletionCommands/RicExportCompletionDataSettingsUi.h

@@ -43,6 +43,13 @@ public:
 
     caf::PdmField<int>                      timeStep;
 
+    void                                    showForSimWells();
+    void                                    showForWellPath();
+
 protected:
-    virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;
+    virtual QList<caf::PdmOptionItemInfo>   calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;
+    virtual void                            defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
+
+private:
+    bool                                    m_displayForSimWell;
 };

ApplicationCode/Commands/CompletionCommands/RicExportFractureCompletionsImpl.cpp

@@ -18,33 +18,96 @@
 
 #include "RicExportFractureCompletionsImpl.h"
 
-#include <vector>
-#include "RimEclipseCase.h"
 #include "RicExportCompletionDataSettingsUi.h"
+
+#include "RimEclipseCase.h"
 #include "RimFracture.h"
 #include "RimWellPath.h"
+#include "RimFractureTemplate.h"
+#include "RimEclipseWell.h"
+#include "RimSimWellFractureCollection.h"
+#include "RimSimWellFracture.h"
+
 #include "RigEclipseCaseData.h"
 #include "RigTransmissibilityCondenser.h"
 #include "RigFractureCell.h"
 #include "RigFractureGrid.h"
-#include "RimFractureTemplate.h"
 #include "RigEclipseToStimPlanCellTransmissibilityCalculator.h"
 #include "RigFractureTransmissibilityEquations.h"
 #include "RigWellPathStimplanIntersector.h"
 #include "RigMainGrid.h"
+#include "RigSingleWellResultsData.h"
+#include "RigSimulationWellCoordsAndMD.h"
+#include "RigWellPath.h"
+
+#include <vector>
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFracturesCompdatValues(const RimWellPath* wellPath, 
+std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdatValuesForWellPath(const RimWellPath* wellPath, 
-                                                                                                const RicExportCompletionDataSettingsUi& settings, 
+                                                                                                  const RicExportCompletionDataSettingsUi& settings, 
-                                                                                                QTextStream* outputStreamForIntermediateResultsText)
+                                                                                                  QTextStream* outputStreamForIntermediateResultsText)
 {
     const RimEclipseCase* caseToApply = settings.caseToApply();
 
     std::vector<RimFracture*> fracturesAlongWellPath;
     wellPath->descendantsIncludingThisOfType(fracturesAlongWellPath);
 
+    return generateCompdatValues(caseToApply,
+                                 wellPath->name(),
+                                 wellPath->wellPathGeometry(),
+                                 fracturesAlongWellPath,
+                                 outputStreamForIntermediateResultsText);
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdatValuesForSimWell(const RimEclipseCase* eclipseCase,
+                                                                                                 const RimEclipseWell* well,
+                                                                                                 size_t timeStep,
+                                                                                                 QTextStream* outputStreamForIntermediateResultsText)
+{
+    std::vector<RigCompletionData> completionData;
+
+    std::vector< std::vector <cvf::Vec3d> > pipeBranchesCLCoords;
+    std::vector< std::vector <RigWellResultPoint> > pipeBranchesCellIds;
+    well->calculateWellPipeDynamicCenterLine(timeStep, pipeBranchesCLCoords, pipeBranchesCellIds);
+
+    for (size_t branchIndex = 0; branchIndex < pipeBranchesCLCoords.size(); ++branchIndex)
+    {
+        RigSimulationWellCoordsAndMD coordsAndMD(pipeBranchesCLCoords[branchIndex]);
+        RigWellPath wellPathGeometry;
+        wellPathGeometry.m_wellPathPoints = coordsAndMD.wellPathPoints();
+        wellPathGeometry.m_measuredDepths = coordsAndMD.measuredDepths();
+
+        std::vector<RimFracture*> fractures;
+        for (RimSimWellFracture* fracture : well->simwellFractureCollection->simwellFractures())
+        {
+            if (static_cast<size_t>(fracture->branchIndex()) == branchIndex)
+            {
+                fractures.push_back(fracture);
+            }
+        }
+
+        std::vector<RigCompletionData> branchCompletions = generateCompdatValues(eclipseCase, well->name(), &wellPathGeometry, fractures, outputStreamForIntermediateResultsText);
+
+        completionData.insert(completionData.end(), branchCompletions.begin(), branchCompletions.end());
+    }
+
+    return completionData;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdatValues(const RimEclipseCase* caseToApply,
+                                                                                       const QString& wellPathName,
+                                                                                       const RigWellPath* wellPathGeometry,
+                                                                                       const std::vector<RimFracture*> fractures,
+                                                                                       QTextStream* outputStreamForIntermediateResultsText)
+{
     double cDarcyInCorrectUnit = caseToApply->eclipseCaseData()->darchysValue();
     const RigMainGrid* mainGrid = caseToApply->eclipseCaseData()->mainGrid();
 
@@ -54,7 +117,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
     std::map <size_t, std::map<RimFracture*, double> > eclCellIdxToTransPrFractureMap; 
     std::vector<RigCompletionData> fractureCompletions; 
 
-    for (RimFracture* fracture : fracturesAlongWellPath)
+    for (RimFracture* fracture : fractures)
     {
 
         bool fractureFiniteCond = (fracture->fractureTemplate()->conductivityType() == RimFractureTemplate::FINITE_CONDUCTIVITY);
@@ -193,7 +256,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
             //If fracture has orientation along well, linear inflow along well and radial flow at endpoints
             else if (fracture->fractureTemplate()->orientationType() == RimFractureTemplate::ALONG_WELL_PATH)
             {
-                RigWellPathStimplanIntersector wellFractureIntersector(wellPath->wellPathGeometry(), fracture);
+                RigWellPathStimplanIntersector wellFractureIntersector(wellPathGeometry, fracture);
                 const std::map<size_t, RigWellPathStimplanIntersector::WellCellIntersection >& fractureWellCells =  wellFractureIntersector.intersections();
 
                 for (const auto& fracCellIdxIsectDataPair : fractureWellCells)
@@ -250,7 +313,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
                 size_t i, j, k;
                 mainGrid->ijkFromCellIndex(externalCell.m_globalCellIdx, &i, &j, &k);
 
-                RigCompletionData compDat(wellPath->name(), {i,j,k} );
+                RigCompletionData compDat(wellPathName, {i,j,k} );
                 compDat.setFromFracture(trans, fracture->fractureTemplate()->skinFactor());
                 compDat.addMetadata(fracture->name(), QString::number(trans));
                 fractureCompletions.push_back(compDat);
@@ -268,7 +331,6 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
     } 
 
     return fractureCompletions;
-
 }
 
 

ApplicationCode/Commands/CompletionCommands/RicExportFractureCompletionsImpl.h

@@ -21,13 +21,29 @@ class RicExportCompletionDataSettingsUi;
 
 #include <vector>
 #include "RigCompletionData.h"
+
 class QTextStream;
+class RigWellPath;
+class RimEclipseCase;
+class RimEclipseWell;
+class RimFracture;
 
 class RicExportFractureCompletionsImpl
 {
 public:
-    static std::vector<RigCompletionData> generateFracturesCompdatValues(const RimWellPath* wellPath,
+    static std::vector<RigCompletionData> generateCompdatValuesForWellPath(const RimWellPath* wellPath,
-                                                                         const RicExportCompletionDataSettingsUi& settings, 
+                                                                           const RicExportCompletionDataSettingsUi& settings, 
-                                                                         QTextStream* outputStreamForIntermediateResultsText);
+                                                                           QTextStream* outputStreamForIntermediateResultsText);
 
+    static std::vector<RigCompletionData> generateCompdatValuesForSimWell(const RimEclipseCase* eclipseCase,
+                                                                          const RimEclipseWell* well,
+                                                                          size_t timeStep,
+                                                                          QTextStream* outputStreamForIntermediateResultsText);
+
+private:
+    static std::vector<RigCompletionData> generateCompdatValues(const RimEclipseCase* caseToApply,
+                                                                const QString& wellPathName,
+                                                                const RigWellPath* wellPathGeometry,
+                                                                const std::vector<RimFracture*> fractures,
+                                                                QTextStream* outputStreamForIntermediateResultsText);
 };

ApplicationCode/Commands/CompletionCommands/RicWellPathExportCompletionDataFeature.cpp

@@ -31,6 +31,8 @@
 #include "RimPerforationInterval.h"
 #include "RimPerforationCollection.h"
 #include "RimReservoirCellResultsStorage.h"
+#include "RimEclipseWell.h"
+#include "RimEclipseWellCollection.h"
 
 #include "RicExportCompletionDataSettingsUi.h"
 
@@ -61,7 +63,32 @@ CAF_CMD_SOURCE_INIT(RicWellPathExportCompletionDataFeature, "RicWellPathExportCo
 //--------------------------------------------------------------------------------------------------
 bool RicWellPathExportCompletionDataFeature::isCommandEnabled()
 {
-    return !selectedWellPaths().empty();
+    std::vector<RimWellPath*> wellPaths = selectedWellPaths();
+    std::vector<RimEclipseWell*> simWells = selectedSimWells();
+
+    if (wellPaths.empty() && simWells.empty())
+    {
+        return false;
+    }
+
+    if (!wellPaths.empty() && !simWells.empty())
+    {
+        return false;
+    }
+
+    std::set<RimEclipseCase*> eclipseCases;
+    for (auto simWell : simWells)
+    {
+        RimEclipseCase* eclipseCase;
+        simWell->firstAncestorOrThisOfType(eclipseCase);
+        eclipseCases.insert(eclipseCase);
+    }
+    if (eclipseCases.size() > 1)
+    {
+        return false;
+    }
+
+    return true;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -70,8 +97,9 @@ bool RicWellPathExportCompletionDataFeature::isCommandEnabled()
 void RicWellPathExportCompletionDataFeature::onActionTriggered(bool isChecked)
 {
     std::vector<RimWellPath*> wellPaths = selectedWellPaths();
+    std::vector<RimEclipseWell*> simWells = selectedSimWells();
 
-    CVF_ASSERT(wellPaths.size() > 0);
+    CVF_ASSERT(wellPaths.size() > 0 || simWells.size() > 0);
 
     RiaApplication* app = RiaApplication::instance();
 
@@ -79,6 +107,16 @@ void RicWellPathExportCompletionDataFeature::onActionTriggered(bool isChecked)
     QString defaultDir = RiaApplication::instance()->lastUsedDialogDirectoryWithFallback("COMPLETIONS", projectFolder);
 
     RicExportCompletionDataSettingsUi exportSettings;
+
+    if (wellPaths.empty())
+    {
+        exportSettings.showForSimWells();
+    }
+    else
+    {
+        exportSettings.showForWellPath();
+    }
+
     std::vector<RimCase*> cases;
     app->project()->allCases(cases);
     for (auto c : cases)
@@ -98,7 +136,7 @@ void RicWellPathExportCompletionDataFeature::onActionTriggered(bool isChecked)
     {
         RiaApplication::instance()->setLastUsedDialogDirectory("COMPLETIONS", QFileInfo(exportSettings.fileName).absolutePath());
 
-        exportCompletions(wellPaths, exportSettings);
+        exportCompletions(wellPaths, simWells, exportSettings);
     }
 }
 
@@ -137,7 +175,32 @@ std::vector<RimWellPath*> RicWellPathExportCompletionDataFeature::selectedWellPa
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector<RimWellPath*>& wellPaths, const RicExportCompletionDataSettingsUi& exportSettings)
+std::vector<RimEclipseWell*> RicWellPathExportCompletionDataFeature::selectedSimWells()
+{
+    std::vector<RimEclipseWell*> simWells;
+    caf::SelectionManager::instance()->objectsByType(&simWells);
+
+    std::vector<RimEclipseWellCollection*> simWellCollections;
+    caf::SelectionManager::instance()->objectsByType(&simWellCollections);
+
+    for (auto simWellCollection : simWellCollections)
+    {
+        for (auto simWell : simWellCollection->wells())
+        {
+            simWells.push_back(simWell);
+        }
+    }
+
+    std::set<RimEclipseWell*> uniqueSimWells(simWells.begin(), simWells.end());
+    simWells.assign(uniqueSimWells.begin(), uniqueSimWells.end());
+
+    return simWells;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector<RimWellPath*>& wellPaths, const std::vector<RimEclipseWell*>& simWells, const RicExportCompletionDataSettingsUi& exportSettings)
 {
     QFile exportFile(exportSettings.fileName());
 
@@ -168,6 +231,16 @@ void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector
                 break;
             }
         }
+        for (const RimEclipseWell* simWell : simWells)
+        {
+            RimEclipseCase* eclipseCase;
+            simWell->firstAncestorOrThisOfType(eclipseCase);
+            if (exportSettings.caseToApply->eclipseCaseData()->unitsType() != eclipseCase->eclipseCaseData()->unitsType())
+            {
+                unitSystemMismatch = true;
+                break;
+            }
+        }
         if (unitSystemMismatch)
         {
             RiaLogging::error("Well path unit systems must match unit system of chosen eclipse case.");
@@ -199,13 +272,18 @@ void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector
 
         if (exportSettings.includeFractures())
         {
-            std::vector<RigCompletionData> fractureCompletionData = 
+            std::vector<RigCompletionData> fractureCompletionData = RicExportFractureCompletionsImpl::generateCompdatValuesForWellPath(wellPath, exportSettings, &stream);
-                RicExportFractureCompletionsImpl::generateFracturesCompdatValues(wellPath, exportSettings, &stream);
             appendCompletionData(&completionData, fractureCompletionData);
         }
 
     }
 
+    for (auto simWell : simWells)
+    {
+        std::vector<RigCompletionData> fractureCompletionData = RicExportFractureCompletionsImpl::generateCompdatValuesForSimWell(exportSettings.caseToApply(), simWell, exportSettings.timeStep(), &stream);
+        appendCompletionData(&completionData, fractureCompletionData);
+    }
+
     // Merge map into a vector of values
     std::vector<RigCompletionData> completions;
     for (auto& data : completionData)

ApplicationCode/Commands/CompletionCommands/RicWellPathExportCompletionDataFeature.h

@@ -33,6 +33,7 @@
 
 class RimWellPath;
 class RimEclipseCase;
+class RimEclipseWell;
 class RigEclipseCaseData;
 class RigMainGrid;
 class RigCell;
@@ -126,13 +127,14 @@ protected:
     virtual void setupActionLook(QAction* actionToSetup) override;
 
     std::vector<RimWellPath*>                    selectedWellPaths();
+    std::vector<RimEclipseWell*>                 selectedSimWells();
 
 public:
     static std::vector<WellSegmentLocation>      findWellSegmentLocations(const RimEclipseCase* caseToApply, const RimWellPath* wellPath);
     static std::vector<WellSegmentLocation>      findWellSegmentLocations(const RimEclipseCase* caseToApply, const RimWellPath* wellPath, const std::vector<RimFishbonesMultipleSubs*>& fishbonesSubs);
 
 private:
-    static void                                  exportCompletions(const std::vector<RimWellPath*>& wellPaths, const RicExportCompletionDataSettingsUi& exportSettings);
+    static void                                  exportCompletions(const std::vector<RimWellPath*>& wellPaths, const std::vector<RimEclipseWell*>& simWells, const RicExportCompletionDataSettingsUi& exportSettings);
 
     static void                                  generateCompdatTable(RifEclipseDataTableFormatter& formatter, const std::vector<RigCompletionData>& completionData);
     static void                                  generateWpimultTable(RifEclipseDataTableFormatter& formatter, const std::vector<RigCompletionData>& completionData);

ApplicationCode/ProjectDataModel/Completions/RimSimWellFracture.h

@@ -47,6 +47,7 @@ public:
     double                                          wellAzimuthAtFracturePosition() override;
     double                                          wellDipAtFracturePosition();
 
+    int                                             branchIndex() const { return m_branchIndex(); }
 
 protected:
     virtual void                                    defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;

ApplicationCode/ProjectDataModel/RimEclipseWell.cpp

@@ -166,7 +166,7 @@ void RimEclipseWell::calculateWellPipeStaticCenterLine(std::vector< std::vector
 //--------------------------------------------------------------------------------------------------
 void RimEclipseWell::calculateWellPipeDynamicCenterLine(size_t timeStepIdx, 
                                                  std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords, 
-                                                 std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds)
+                                                 std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) const
 {
     RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(this, timeStepIdx, pipeBranchesCLCoords, pipeBranchesCellIds);
 }

ApplicationCode/ProjectDataModel/RimEclipseWell.h

@@ -70,7 +70,7 @@ public:
 
     void                                calculateWellPipeDynamicCenterLine(size_t timeStepIdx, 
                                                                     std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
-                                                                    std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds);
+                                                                    std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) const;
 
     void                                wellHeadTopBottomPosition(size_t frameIndex, cvf::Vec3d* top,  cvf::Vec3d* bottom);
     double                              pipeRadius();

ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp

@@ -45,14 +45,14 @@ void RigSimulationWellCenterLineCalculator::calculateWellPipeStaticCenterline(Ri
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(RimEclipseWell* rimWell, 
+void RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(const RimEclipseWell* rimWell, 
                                                                                size_t timeStepIndex, 
                                                                                std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords, 
                                                                                std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds)
 {
     CVF_ASSERT(rimWell);
 
-    RigSingleWellResultsData*  wellResults = rimWell->wellResults();
+    const RigSingleWellResultsData*  wellResults = rimWell->wellResults();
 
     RimEclipseView* eclipseView;
     rimWell->firstAncestorOrThisOfType(eclipseView);

ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.h

@@ -32,7 +32,7 @@ public:
                                                   std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
                                                   std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) ;
 
-    static void calculateWellPipeDynamicCenterline(RimEclipseWell* rimWell, 
+    static void calculateWellPipeDynamicCenterline(const RimEclipseWell* rimWell, 
                                                    size_t timeStepIndex,
                                                    std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
                                                    std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) ;