#7818 Modeled Well Path : Add support for creation of N laterals based on a template

ApplicationLibCode/ProjectDataModel/CMakeLists_files.cmake

@@ -154,6 +154,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimTimeAxisAnnotation.h
 ${CMAKE_CURRENT_LIST_DIR}/RimPolylinesDataInterface.h
 ${CMAKE_CURRENT_LIST_DIR}/RimWellPathTieIn.h
 ${CMAKE_CURRENT_LIST_DIR}/cafTreeNode.h
+${CMAKE_CURRENT_LIST_DIR}/RimMultipleLocations.h
 )
 
 
@@ -308,6 +309,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimEquilibriumAxisAnnotation.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimTimeAxisAnnotation.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimWellPathTieIn.cpp
 ${CMAKE_CURRENT_LIST_DIR}/cafTreeNode.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimMultipleLocations.cpp
 )
 
 if(Qt5Charts_FOUND)

ApplicationLibCode/ProjectDataModel/RimContextCommandBuilder.cpp

@@ -404,6 +404,7 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
             if ( dynamic_cast<RimModeledWellPath*>( firstUiItem ) )
             {
                 menuBuilder << "RicShowWellPlanFeature";
+                menuBuilder << "RicCreateMultipleWellPathLaterals";
             }
         }
         else if ( dynamic_cast<RimWellPathCompletions*>( firstUiItem ) )

ApplicationLibCode/ProjectDataModel/RimMultipleLocations.cpp

@@ -0,0 +1,369 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2021 Equinor 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 "RimMultipleLocations.h"
+
+#include "cafPdmUiDoubleValueEditor.h"
+#include "cafPdmUiListEditor.h"
+
+#include <cmath>
+
+CAF_PDM_SOURCE_INIT( RimMultipleLocations, "RimMultipleLocations" );
+
+namespace caf
+{
+template <>
+void AppEnum<RimMultipleLocations::LocationType>::setUp()
+{
+    addItem( RimMultipleLocations::LocationType::COUNT, "COUNT", "Start/End/Number" );
+    addItem( RimMultipleLocations::LocationType::SPACING, "SPACING", "Start/End/Spacing" );
+    addItem( RimMultipleLocations::LocationType::CUSTOM, "CUSTOM", "User Specification" );
+    setDefault( RimMultipleLocations::LocationType::COUNT );
+}
+} // namespace caf
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimMultipleLocations::RimMultipleLocations()
+{
+    CAF_PDM_InitObject( "RimMultipleLocations", ":/FishBoneGroup16x16.png", "", "" );
+
+    CAF_PDM_InitField( &m_locationType,
+                       "LocationMode",
+                       caf::AppEnum<LocationType>( LocationType::COUNT ),
+                       "Location Defined By",
+                       "",
+                       "",
+                       "" );
+    CAF_PDM_InitField( &m_rangeStart, "RangeStart", 100.0, "Start MD", "", "", "" );
+    m_rangeStart.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
+
+    CAF_PDM_InitField( &m_rangeEnd, "RangeEnd", 250.0, "End MD", "", "", "" );
+    m_rangeEnd.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
+
+    CAF_PDM_InitFieldNoDefault( &m_rangeSpacing, "Spacing", "Spacing", "", "", "" );
+    m_rangeSpacing.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
+
+    CAF_PDM_InitFieldNoDefault( &m_minimumMD, "MinimumMD", "Minimum MD", "", "", "" );
+    m_minimumMD.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
+
+    CAF_PDM_InitFieldNoDefault( &m_maximumMD, "MaximumMD", "Maximum MD", "", "", "" );
+    m_maximumMD.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
+
+    CAF_PDM_InitField( &m_rangeCount, "RangeValveCount", 10, "Number of Items", "", "", "" );
+
+    CAF_PDM_InitFieldNoDefault( &m_locations, "Locations", "Measured Depths", "", "", "" );
+    m_locations.uiCapability()->setUiEditorTypeName( caf::PdmUiListEditor::uiEditorTypeName() );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimMultipleLocations::setRange( double minimumMD, double maximumMD )
+{
+    m_minimumMD = minimumMD;
+    m_maximumMD = maximumMD;
+
+    m_rangeStart = minimumMD;
+    m_rangeEnd   = maximumMD;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimMultipleLocations::updateRangesAndLocations()
+{
+    double existingRangeStart = m_rangeStart();
+    double existingRangeEnd   = m_rangeEnd();
+    m_rangeStart              = std::clamp( m_rangeStart(), minimumMD(), maximumMD() );
+    m_rangeEnd                = std::clamp( m_rangeEnd(), minimumMD(), maximumMD() );
+    if ( existingRangeStart != m_rangeStart() || existingRangeEnd != m_rangeEnd() )
+    {
+        computeRangesAndLocations();
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimMultipleLocations::measuredDepth( size_t valveIndex ) const
+{
+    return m_locations()[valveIndex];
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimMultipleLocations::rangeStart() const
+{
+    return m_rangeStart;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimMultipleLocations::rangeEnd() const
+{
+    return m_rangeEnd;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+const std::vector<double>& RimMultipleLocations::locations() const
+{
+    return m_locations();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimMultipleLocations::setLocationType( LocationType locationType )
+{
+    m_locationType = locationType;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimMultipleLocations::computeRangesAndLocations()
+{
+    if ( m_locationType == LocationType::COUNT )
+    {
+        int divisor = 1;
+        if ( m_rangeCount > 2 ) divisor = m_rangeCount - 1;
+
+        m_rangeSpacing = std::abs( m_rangeStart - m_rangeEnd ) / divisor;
+        if ( m_rangeSpacing < minimumSpacingMeters() )
+        {
+            m_rangeSpacing = minimumSpacingMeters();
+            m_rangeCount   = rangeCountFromSpacing();
+        }
+    }
+    else if ( m_locationType == LocationType::SPACING )
+    {
+        m_rangeCount = rangeCountFromSpacing();
+    }
+
+    if ( m_locationType == LocationType::COUNT || m_locationType == LocationType::SPACING )
+    {
+        std::vector<double> validMeasuredDepths;
+        for ( auto md : locationsFromStartSpacingAndCount( m_rangeStart(), m_rangeSpacing, m_rangeCount ) )
+        {
+            validMeasuredDepths.push_back( md );
+        }
+
+        m_locations = validMeasuredDepths;
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimMultipleLocations::initFields( LocationType               locationType,
+                                       double                     rangeStart,
+                                       double                     rangeEnd,
+                                       double                     valveSpacing,
+                                       int                        valveCount,
+                                       const std::vector<double>& locationOfValves )
+{
+    if ( locationType != LocationType::UNDEFINED )
+    {
+        m_locationType = locationType;
+    }
+    if ( rangeStart != std::numeric_limits<double>::infinity() )
+    {
+        m_rangeStart = rangeStart;
+    }
+    if ( rangeEnd != std::numeric_limits<double>::infinity() )
+    {
+        m_rangeEnd = rangeEnd;
+    }
+    if ( valveSpacing != std::numeric_limits<double>::infinity() )
+    {
+        m_rangeSpacing = valveSpacing;
+    }
+    if ( valveCount != -1 )
+    {
+        m_rangeCount = valveCount;
+    }
+    if ( !locationOfValves.empty() )
+    {
+        m_locations = locationOfValves;
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimMultipleLocations::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
+{
+    {
+        m_locations.uiCapability()->setUiName( "Measured Depths" );
+        m_rangeStart.uiCapability()->setUiName( "Start MD" );
+        m_rangeEnd.uiCapability()->setUiName( "End MD" );
+        m_rangeSpacing.uiCapability()->setUiName( "Spacing" );
+    }
+
+    {
+        uiOrdering.add( &m_locationType );
+        if ( m_locationType() != LocationType::CUSTOM )
+        {
+            uiOrdering.add( &m_rangeStart );
+            uiOrdering.add( &m_rangeEnd );
+
+            if ( m_locationType() == LocationType::COUNT )
+            {
+                uiOrdering.add( &m_rangeCount );
+                uiOrdering.add( &m_rangeSpacing );
+            }
+            else if ( m_locationType() == LocationType::SPACING )
+            {
+                uiOrdering.add( &m_rangeSpacing );
+                uiOrdering.add( &m_rangeCount );
+            }
+        }
+
+        uiOrdering.add( &m_locations );
+    }
+
+    if ( m_locationType() == LocationType::CUSTOM )
+    {
+        m_locations.uiCapability()->setUiReadOnly( false );
+
+        m_rangeSpacing.uiCapability()->setUiReadOnly( true );
+        m_rangeCount.uiCapability()->setUiReadOnly( true );
+        m_rangeStart.uiCapability()->setUiReadOnly( true );
+        m_rangeEnd.uiCapability()->setUiReadOnly( true );
+    }
+    else
+    {
+        m_locations.uiCapability()->setUiReadOnly( true );
+
+        m_rangeSpacing.uiCapability()->setUiReadOnly( false );
+        m_rangeCount.uiCapability()->setUiReadOnly( false );
+        m_rangeStart.uiCapability()->setUiReadOnly( false );
+        m_rangeEnd.uiCapability()->setUiReadOnly( false );
+
+        if ( m_locationType() == LocationType::COUNT )
+        {
+            m_rangeSpacing.uiCapability()->setUiReadOnly( true );
+            m_rangeCount.uiCapability()->setUiReadOnly( false );
+        }
+        else
+        {
+            m_rangeSpacing.uiCapability()->setUiReadOnly( false );
+            m_rangeCount.uiCapability()->setUiReadOnly( true );
+        }
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimMultipleLocations::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
+                                             const QVariant&            oldValue,
+                                             const QVariant&            newValue )
+{
+    bool recomputeLocations = false;
+
+    if ( changedField == &m_locationType )
+    {
+        if ( m_locationType == LocationType::COUNT || m_locationType == LocationType::SPACING )
+        {
+            recomputeLocations = true;
+        }
+    }
+
+    if ( changedField == &m_rangeStart || changedField == &m_rangeEnd || changedField == &m_rangeCount ||
+         changedField == &m_rangeSpacing )
+    {
+        recomputeLocations = true;
+        m_rangeStart       = std::clamp( m_rangeStart(), minimumMD(), maximumMD() );
+        m_rangeEnd         = std::clamp( m_rangeEnd(), minimumMD(), maximumMD() );
+    }
+
+    if ( changedField == &m_rangeSpacing )
+    {
+        double minimumDistanceMeter = minimumSpacingMeters();
+
+        m_rangeSpacing =
+            std::clamp( m_rangeSpacing(), minimumDistanceMeter, std::max( m_rangeSpacing(), minimumDistanceMeter ) );
+    }
+
+    if ( recomputeLocations )
+    {
+        computeRangesAndLocations();
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+int RimMultipleLocations::rangeCountFromSpacing() const
+{
+    int rangeCount = ( std::fabs( m_rangeStart - m_rangeEnd ) / m_rangeSpacing ) + 1;
+
+    if ( rangeCount < 1 )
+    {
+        rangeCount = 1;
+    }
+    return rangeCount;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimMultipleLocations::minimumSpacingMeters() const
+{
+    // Minimum distance between fishbones is 13.0m
+    // Use 10.0m to allow for some flexibility
+    return 10.0;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimMultipleLocations::minimumMD() const
+{
+    return m_rangeStart();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+double RimMultipleLocations::maximumMD() const
+{
+    return m_rangeEnd();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<double> RimMultipleLocations::locationsFromStartSpacingAndCount( double start, double spacing, size_t count )
+{
+    std::vector<double> measuredDepths;
+
+    for ( size_t i = 0; i < count; i++ )
+    {
+        measuredDepths.push_back( start + spacing * i );
+    }
+
+    return measuredDepths;
+}

ApplicationLibCode/ProjectDataModel/RimMultipleLocations.h

@@ -0,0 +1,82 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2021 Equinor 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 "cafAppEnum.h"
+#include "cafPdmBase.h"
+#include "cafPdmField.h"
+#include "cafPdmObject.h"
+
+class RimMultipleLocations : public caf::PdmObject
+{
+    CAF_PDM_HEADER_INIT;
+
+public:
+    enum class LocationType
+    {
+        COUNT,
+        SPACING,
+        CUSTOM,
+        UNDEFINED
+    };
+
+public:
+    RimMultipleLocations();
+
+    void setRange( double minimumMD, double maximumMD );
+
+    void                       updateRangesAndLocations();
+    double                     measuredDepth( size_t valveIndex ) const;
+    double                     rangeStart() const;
+    double                     rangeEnd() const;
+    const std::vector<double>& locations() const;
+
+    void setLocationType( LocationType locationType );
+    void computeRangesAndLocations();
+
+    void initFields( LocationType               locationType,
+                     double                     rangeStart,
+                     double                     rangeEnd,
+                     double                     valveSpacing,
+                     int                        valveCount,
+                     const std::vector<double>& locationOfValves );
+
+protected:
+    void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
+    void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
+
+private:
+    int                        rangeCountFromSpacing() const;
+    double                     minimumSpacingMeters() const;
+    double                     minimumMD() const;
+    double                     maximumMD() const;
+    static std::vector<double> locationsFromStartSpacingAndCount( double start, double spacing, size_t count );
+
+private:
+    caf::PdmField<caf::AppEnum<LocationType>> m_locationType;
+    caf::PdmField<double>                     m_rangeStart;
+    caf::PdmField<double>                     m_rangeEnd;
+    caf::PdmField<double>                     m_rangeSpacing;
+    caf::PdmField<int>                        m_rangeCount;
+
+    caf::PdmField<double> m_minimumMD;
+    caf::PdmField<double> m_maximumMD;
+
+    caf::PdmField<std::vector<double>> m_locations; // Given in measured depth
+};

ApplicationLibCode/ProjectDataModel/RimWellPathCollection.cpp

@@ -60,6 +60,7 @@
 #include "cafPdmUiTreeOrdering.h"
 #include "cafProgressInfo.h"
 
+#include <QCollator>
 #include <QFile>
 #include <QFileInfo>
 #include <QString>
@@ -729,7 +730,13 @@ void RimWellPathCollection::removeWellPath( gsl::not_null<RimWellPath*> wellPath
 bool lessWellPath( const caf::PdmPointer<RimWellPath>& w1, const caf::PdmPointer<RimWellPath>& w2 )
 {
     if ( w1.notNull() && w2.notNull() )
-        return ( w1->name() < w2->name() );
+    {
+        // Use QCollator to sort integer values in addition to text
+
+        QCollator collator;
+        collator.setNumericMode( true );
+        return collator.compare( w1->name(), w2->name() ) < 0;
+    }
     else if ( w1.notNull() )
         return true;
     else
@@ -906,6 +913,11 @@ std::map<QString, std::vector<RimWellPath*>>
         rootWells[RimWellPathCollection::unGroupedText()].push_back( wellPath );
     }
 
+    for ( auto [groupName, wellPaths] : rootWells )
+    {
+        std::sort( wellPaths.begin(), wellPaths.end(), lessWellPath );
+    }
+
     return rootWells;
 }
 

ApplicationLibCode/ProjectDataModel/RimWellPathCollection.h

@@ -102,6 +102,8 @@ public:
     void groupWellPaths( const std::vector<RimWellPath*>& wellPaths );
     void rebuildWellPathNodes();
 
+    std::vector<RimWellPath*> connectedWellPathLaterals( const RimWellPath* parentWellPath ) const;
+
     RimWellPath* mostRecentlyUpdatedWellPath();
 
     void readWellPathFormationFiles();
@@ -146,7 +148,6 @@ private:
     cafTreeNode* addWellToWellNode( cafTreeNode* parent, RimWellPath* wellPath );
 
     std::vector<RimWellPath*> wellPathsWithNoParent( const std::vector<RimWellPath*>& sourceWellPaths ) const;
-    std::vector<RimWellPath*> connectedWellPathLaterals( const RimWellPath* parentWellPath ) const;
 
     std::map<QString, std::vector<RimWellPath*>>
         wellPathsForWellNameStem( const std::vector<RimWellPath*>& sourceWellPaths ) const;

ApplicationLibCode/ProjectDataModel/RimWellPathTieIn.cpp

@@ -79,6 +79,14 @@ double RimWellPathTieIn::tieInMeasuredDepth() const
     return m_tieInMeasuredDepth();
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimWellPathTieIn::setTieInMeasuredDepth( double measuredDepth )
+{
+    m_tieInMeasuredDepth = measuredDepth;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimWellPathTieIn.h

@@ -36,6 +36,7 @@ public:
     void         connectWellPaths( RimWellPath* parentWell, RimWellPath* childWell, double tieInMeasuredDepth );
     RimWellPath* parentWell() const;
     double       tieInMeasuredDepth() const;
+    void         setTieInMeasuredDepth( double measuredDepth );
 
     RimWellPath* childWell() const;
     void         updateChildWellGeometry();