#14956: Rename well event Tubing to Segment

Rename RimWellEventTubing to RimWellEventSegment (keyword WellEventSegment),
EventType::TUBING to SEGMENT, and the scripting method AddTubingEvent to
AddSegmentEvent (Python: add_segment_event). Update the project tree label,
schedule comments, Python helpers, examples, tests and docs.

ApplicationLibCode/Commands/CompletionExportCommands/RicScheduleDataGenerator.cpp

@@ -420,7 +420,7 @@ std::expected<QString, QString> RicScheduleDataGenerator::generateDateSection( c
             {
                 isRelevant = keywordName == "COMPDAT";
             }
-            else if ( event->eventType() == RimWellEvent::EventType::TUBING )
+            else if ( event->eventType() == RimWellEvent::EventType::SEGMENT )
             {
                 isRelevant = keywordName == "WELSEGS";
             }
@@ -550,7 +550,7 @@ std::optional<Opm::DeckKeyword> RicScheduleDataGenerator::generateWelspecsForWel
     bool hasEvents = false;
     for ( auto* event : eventsAtDate )
     {
-        if ( ( event->eventType() == RimWellEvent::EventType::PERF || event->eventType() == RimWellEvent::EventType::TUBING ||
+        if ( ( event->eventType() == RimWellEvent::EventType::PERF || event->eventType() == RimWellEvent::EventType::SEGMENT ||
                event->eventType() == RimWellEvent::EventType::WELLSPEC ) &&
              eventBelongsToWell( *event, well ) )
         {
@@ -653,9 +653,9 @@ void RicScheduleDataGenerator::generateMswForWell( RimEclipseCase&
         return;
     }
 
-    // MSW is generated only when there are valve/tubing/perforation events at this exact date.
+    // MSW is generated only when there are valve/segment/perforation events at this exact date.
     bool hasValveEvents    = false;
-    bool hasGeometryEvents = false; // tubing or perforation changes require WELSEGS/COMPSEGS to be redefined
+    bool hasGeometryEvents = false; // segment or perforation changes require WELSEGS/COMPSEGS to be redefined
     for ( auto* event : eventsAtDate )
     {
         if ( !eventBelongsToWell( *event, wellPath ) ) continue;
@@ -664,7 +664,7 @@ void RicScheduleDataGenerator::generateMswForWell( RimEclipseCase&
         {
             hasValveEvents = true;
         }
-        else if ( event->eventType() == RimWellEvent::EventType::TUBING || event->eventType() == RimWellEvent::EventType::PERF )
+        else if ( event->eventType() == RimWellEvent::EventType::SEGMENT || event->eventType() == RimWellEvent::EventType::PERF )
         {
             hasGeometryEvents = true;
         }
@@ -699,7 +699,7 @@ void RicScheduleDataGenerator::generateMswForWell( RimEclipseCase&
     auto welsegsKw   = RimKeywordFactory::welsegsKeyword( mswData, maxSegments, maxBranches );
     auto compsegsKw  = RimKeywordFactory::compsegsKeyword( mswData );
 
-    // Tubing and perforation changes always redefine the segments. A valve event usually only updates
+    // Segment and perforation changes always redefine the segments. A valve event usually only updates
     // WSEGVALV/WSEGAICD, but a valve becoming active adds valve segments and remaps connections, so the
     // segments are also redefined when the layout differs from the one last written for this well.
     const QString segmentLayout = RimKeywordFactory::deckKeywordToString( welsegsKw ) + RimKeywordFactory::deckKeywordToString( compsegsKw );

ApplicationLibCode/Commands/CompletionExportCommands/RicScheduleDataGenerator.h

@@ -109,7 +109,7 @@ private:
     // WSEGVALV / WSEGAICD are merged into keywordBlocks; WELSEGS / COMPSEGS cannot be merged across
     // wells and are appended as separate per-well blocks in unmergedBlocks.
     // The caller decides which wells get MSW keywords (see mswWells in generateSchedule).
-    // WELSEGS / COMPSEGS are written for tubing/perforation events, and for valve events when the
+    // WELSEGS / COMPSEGS are written for segment/perforation events, and for valve events when the
     // segment layout differs from the one last written for the well (tracked in emittedSegmentLayouts).
     static void generateMswForWell( RimEclipseCase&                                   eclipseCase,
                                     RimWellPath&                                      well,

ApplicationLibCode/ProjectDataModel/WellEvents/CMakeLists_files.cmake

@@ -4,7 +4,7 @@ set(SOURCE_GROUP_SOURCE_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RimWellEventRawText.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellEventInsertDate.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellEventValve.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/RimWellEventTubing.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RimWellEventSegment.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellEventState.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellEventType.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellEventWellSpec.cpp

ApplicationLibCode/ProjectDataModel/WellEvents/RimWellEvent.cpp

@@ -32,7 +32,7 @@ void AppEnum<RimWellEvent::EventType>::setUp()
 {
     addItem( RimWellEvent::EventType::PERF, "PERF", "Perforation" );
     addItem( RimWellEvent::EventType::VALVE, "VALVE", "Valve" );
-    addItem( RimWellEvent::EventType::TUBING, "TUBING", "Tubing" );
+    addItem( RimWellEvent::EventType::SEGMENT, "SEGMENT", "Segment" );
     addItem( RimWellEvent::EventType::WSTATE, "WSTATE", "Well State" );
     addItem( RimWellEvent::EventType::WTYPE, "WTYPE", "Well Type" );
     addItem( RimWellEvent::EventType::WELLSPEC, "WELLSPEC", "Well Specification" );

ApplicationLibCode/ProjectDataModel/WellEvents/RimWellEvent.h

@@ -42,7 +42,7 @@ public:
     {
         PERF,
         VALVE,
-        TUBING,
+        SEGMENT,
         WSTATE,
         WTYPE,
         WELLSPEC,

ApplicationLibCode/ProjectDataModel/WellEvents/RimWellEventSegment.cpp

@@ -16,19 +16,19 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RimWellEventTubing.h"
+#include "RimWellEventSegment.h"
 
 #include "cafPdmFieldScriptingCapability.h"
 #include "cafPdmObjectScriptingCapability.h"
 
-CAF_PDM_SOURCE_INIT( RimWellEventTubing, "WellEventTubing" );
+CAF_PDM_SOURCE_INIT( RimWellEventSegment, "WellEventSegment" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellEventTubing::RimWellEventTubing()
+RimWellEventSegment::RimWellEventSegment()
 {
-    CAF_PDM_InitScriptableObject( "Tubing Event", "", "", "WellEventTubing" );
+    CAF_PDM_InitScriptableObject( "Segment Event", "", "", "WellEventSegment" );
 
     CAF_PDM_InitScriptableField( &m_startMD, "StartMd", 0.0, "Start MD" );
     CAF_PDM_InitScriptableField( &m_endMD, "EndMd", 0.0, "End MD" );
@@ -41,14 +41,14 @@ RimWellEventTubing::RimWellEventTubing()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellEventTubing::~RimWellEventTubing()
+RimWellEventSegment::~RimWellEventSegment()
 {
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimWellEventTubing::startMD() const
+double RimWellEventSegment::startMD() const
 {
     return m_startMD();
 }
@@ -56,7 +56,7 @@ double RimWellEventTubing::startMD() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimWellEventTubing::endMD() const
+double RimWellEventSegment::endMD() const
 {
     return m_endMD();
 }
@@ -64,7 +64,7 @@ double RimWellEventTubing::endMD() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimWellEventTubing::innerDiameter() const
+double RimWellEventSegment::innerDiameter() const
 {
     return m_innerDiameter();
 }
@@ -72,7 +72,7 @@ double RimWellEventTubing::innerDiameter() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimWellEventTubing::roughness() const
+double RimWellEventSegment::roughness() const
 {
     return m_roughness();
 }
@@ -80,7 +80,7 @@ double RimWellEventTubing::roughness() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellEventTubing::setStartMD( double md )
+void RimWellEventSegment::setStartMD( double md )
 {
     m_startMD = md;
 }
@@ -88,7 +88,7 @@ void RimWellEventTubing::setStartMD( double md )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellEventTubing::setEndMD( double md )
+void RimWellEventSegment::setEndMD( double md )
 {
     m_endMD = md;
 }
@@ -96,7 +96,7 @@ void RimWellEventTubing::setEndMD( double md )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellEventTubing::setInnerDiameter( double diameter )
+void RimWellEventSegment::setInnerDiameter( double diameter )
 {
     m_innerDiameter = diameter;
 }
@@ -104,7 +104,7 @@ void RimWellEventTubing::setInnerDiameter( double diameter )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellEventTubing::setRoughness( double roughness )
+void RimWellEventSegment::setRoughness( double roughness )
 {
     m_roughness = roughness;
 }
@@ -112,19 +112,19 @@ void RimWellEventTubing::setRoughness( double roughness )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellEvent::EventType RimWellEventTubing::eventType() const
+RimWellEvent::EventType RimWellEventSegment::eventType() const
 {
-    return EventType::TUBING;
+    return EventType::SEGMENT;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimWellEventTubing::generateScheduleKeyword( const QString& wellName ) const
+QString RimWellEventSegment::generateScheduleKeyword( const QString& wellName ) const
 {
-    // Generate a comment line describing the tubing change
+    // Generate a comment line describing the segment change
     // Actual WELSEGS segment data requires grid calculations
-    QString line = QString( "-- %1 TUBING: MD %2 - %3, Diam: %4 m, Rough: %5 m\n" )
+    QString line = QString( "-- %1 SEGMENT: MD %2 - %3, Diam: %4 m, Rough: %5 m\n" )
                        .arg( wellName )
                        .arg( m_startMD(), 0, 'f', 2 )
                        .arg( m_endMD(), 0, 'f', 2 )
@@ -137,7 +137,7 @@ QString RimWellEventTubing::generateScheduleKeyword( const QString& wellName ) c
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellEventTubing::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
+void RimWellEventSegment::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
     RimWellEvent::defineUiOrdering( uiConfigName, uiOrdering );
 
@@ -152,9 +152,9 @@ void RimWellEventTubing::defineUiOrdering( QString uiConfigName, caf::PdmUiOrder
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellEventTubing::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName )
+void RimWellEventSegment::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName )
 {
-    setUiName( QString( "TUBING %1: %2 - %3 (D: %4 m)" )
+    setUiName( QString( "SEGMENT %1: %2 - %3 (D: %4 m)" )
                    .arg( m_eventDate().toString( "yyyy-MM-dd" ) )
                    .arg( m_startMD(), 0, 'f', 1 )
                    .arg( m_endMD(), 0, 'f', 1 )

ApplicationLibCode/ProjectDataModel/WellEvents/RimWellEventSegment.h

@@ -24,16 +24,16 @@
 
 //==================================================================================================
 ///
-/// Tubing event - defines changes to tubing/liner diameter and roughness
+/// Segment event - defines changes to segment (tubing/liner) diameter and roughness
 ///
 //==================================================================================================
-class RimWellEventTubing : public RimWellEvent
+class RimWellEventSegment : public RimWellEvent
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimWellEventTubing();
-    ~RimWellEventTubing() override;
+    RimWellEventSegment();
+    ~RimWellEventSegment() override;
 
     // Getters
     double startMD() const;

ApplicationLibCode/ProjectDataModel/WellEvents/RimWellEventTimeline.cpp

@@ -25,8 +25,8 @@
 #include "RimWellEventKeyword.h"
 #include "RimWellEventPerf.h"
 #include "RimWellEventRawText.h"
+#include "RimWellEventSegment.h"
 #include "RimWellEventState.h"
-#include "RimWellEventTubing.h"
 #include "RimWellEventType.h"
 #include "RimWellEventValve.h"
 #include "RimWellEventWellSpec.h"
@@ -247,9 +247,9 @@ RimWellEventValve* RimWellEventTimeline::addValveEvent( RimWellPath* wellPath, c
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellEventTubing* RimWellEventTimeline::addTubingEvent( RimWellPath* wellPath, const QDateTime& date )
+RimWellEventSegment* RimWellEventTimeline::addSegmentEvent( RimWellPath* wellPath, const QDateTime& date )
 {
-    auto* event = new RimWellEventTubing();
+    auto* event = new RimWellEventSegment();
     event->setWellPath( wellPath );
     event->setEventDate( date );
     m_events.push_back( event );
@@ -483,11 +483,11 @@ bool RimWellEventTimeline::applyEvent( RimWellPathCollection* wellPathCollection
                 }
                 break;
             }
-            case RimWellEvent::EventType::TUBING:
+            case RimWellEvent::EventType::SEGMENT:
             {
-                if ( auto* tubingEvent = dynamic_cast<RimWellEventTubing*>( event ) )
+                if ( auto* segmentEvent = dynamic_cast<RimWellEventSegment*>( event ) )
                 {
-                    return applyTubingEvent( *tubingEvent, *wellPath );
+                    return applySegmentEvent( *segmentEvent, *wellPath );
                 }
                 break;
             }
@@ -538,7 +538,7 @@ bool RimWellEventTimeline::applyWellSpecEvent( const RimWellEventWellSpec& event
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimWellEventTimeline::applyTubingEvent( const RimWellEventTubing& event, RimWellPath& wellPath )
+bool RimWellEventTimeline::applySegmentEvent( const RimWellEventSegment& event, RimWellPath& wellPath )
 {
     auto* segmentCollection = wellPath.segmentCollection();
     if ( !segmentCollection )

ApplicationLibCode/ProjectDataModel/WellEvents/RimWellEventTimeline.h

@@ -30,7 +30,7 @@
 
 class RimWellEventPerf;
 class RimWellEventValve;
-class RimWellEventTubing;
+class RimWellEventSegment;
 class RimWellEventState;
 class RimWellEventType;
 class RimWellEventWellSpec;
@@ -76,7 +76,7 @@ public:
     // Add event methods (return the created event for further configuration)
     RimWellEventPerf*       addPerforationEvent( RimWellPath* wellPath, const QDateTime& date );
     RimWellEventValve*      addValveEvent( RimWellPath* wellPath, const QDateTime& date );
-    RimWellEventTubing*     addTubingEvent( RimWellPath* wellPath, const QDateTime& date );
+    RimWellEventSegment*    addSegmentEvent( RimWellPath* wellPath, const QDateTime& date );
     RimWellEventState*      addStateEvent( RimWellPath* wellPath, const QDateTime& date );
     RimWellEventType*       addTypeEvent( RimWellPath* wellPath, const QDateTime& date );
     RimWellEventWellSpec*   addWellSpecEvent( RimWellPath* wellPath, const QDateTime& date );
@@ -113,7 +113,7 @@ protected:
 private:
     bool applyEvent( RimWellPathCollection* wellPathCollection, RimWellEvent* event );
 
-    bool applyTubingEvent( const RimWellEventTubing& event, RimWellPath& wellPath );
+    bool applySegmentEvent( const RimWellEventSegment& event, RimWellPath& wellPath );
     bool applyPerfEvent( const RimWellEventPerf& event, RimWellPath& wellPath );
     bool applyValveEvent( RimWellEventValve& event, RimWellPath& wellPath );
     bool applyWellSpecEvent( const RimWellEventWellSpec& event, RimWellPath& wellPath );

ApplicationLibCode/ProjectDataModelCommands/RimcWellEventTimeline.cpp

@@ -27,9 +27,9 @@
 #include "RimWellEventKeyword.h"
 #include "RimWellEventPerf.h"
 #include "RimWellEventRawText.h"
+#include "RimWellEventSegment.h"
 #include "RimWellEventState.h"
 #include "RimWellEventTimeline.h"
-#include "RimWellEventTubing.h"
 #include "RimWellEventValve.h"
 #include "RimWellEventWellSpec.h"
 #include "RimWellPath.h"
@@ -319,15 +319,15 @@ QString RimcWellEventTimeline_addControlEvent::classKeywordReturnedType() const
     return RimWellEventControl::classKeywordStatic();
 }
 
-CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimWellEventTimeline, RimcWellEventTimeline_addTubingEvent, "AddTubingEvent" );
+CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimWellEventTimeline, RimcWellEventTimeline_addSegmentEvent, "AddSegmentEvent" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimcWellEventTimeline_addTubingEvent::RimcWellEventTimeline_addTubingEvent( caf::PdmObjectHandle* self )
+RimcWellEventTimeline_addSegmentEvent::RimcWellEventTimeline_addSegmentEvent( caf::PdmObjectHandle* self )
     : caf::PdmObjectCreationMethod( self )
 {
-    CAF_PDM_InitObject( "Add Tubing Event", "", "", "Add a tubing event to the timeline" );
+    CAF_PDM_InitObject( "Add Segment Event", "", "", "Add a segment event to the timeline" );
 
     CAF_PDM_InitScriptableField( &m_eventDate, "EventDate", QString( "2024-01-01" ), "", "", "", "Event Date (YYYY-MM-DD)" );
     CAF_PDM_InitScriptableFieldNoDefault( &m_wellPath, "WellPath", "", "", "", "Well Path" );
@@ -340,7 +340,7 @@ RimcWellEventTimeline_addTubingEvent::RimcWellEventTimeline_addTubingEvent( caf:
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::expected<caf::PdmObjectHandle*, QString> RimcWellEventTimeline_addTubingEvent::execute()
+std::expected<caf::PdmObjectHandle*, QString> RimcWellEventTimeline_addSegmentEvent::execute()
 {
     auto timeline = self<RimWellEventTimeline>();
 
@@ -355,7 +355,7 @@ std::expected<caf::PdmObjectHandle*, QString> RimcWellEventTimeline_addTubingEve
         return std::unexpected( QString( "Invalid date format: %1. Expected YYYY-MM-DD" ).arg( m_eventDate() ) );
     }
 
-    auto* event = timeline->addTubingEvent( m_wellPath(), date );
+    auto* event = timeline->addSegmentEvent( m_wellPath(), date );
     event->setStartMD( m_startMd() );
     event->setEndMD( m_endMd() );
     event->setInnerDiameter( m_innerDiameter() );
@@ -367,9 +367,9 @@ std::expected<caf::PdmObjectHandle*, QString> RimcWellEventTimeline_addTubingEve
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimcWellEventTimeline_addTubingEvent::classKeywordReturnedType() const
+QString RimcWellEventTimeline_addSegmentEvent::classKeywordReturnedType() const
 {
-    return RimWellEventTubing::classKeywordStatic();
+    return RimWellEventSegment::classKeywordStatic();
 }
 
 CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimWellEventTimeline, RimcWellEventTimeline_addWellSpecEvent, "AddWellspecEvent" );

ApplicationLibCode/ProjectDataModelCommands/RimcWellEventTimeline.h

@@ -138,12 +138,12 @@ private:
 //==================================================================================================
 ///
 //==================================================================================================
-class RimcWellEventTimeline_addTubingEvent : public caf::PdmObjectCreationMethod
+class RimcWellEventTimeline_addSegmentEvent : public caf::PdmObjectCreationMethod
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimcWellEventTimeline_addTubingEvent( caf::PdmObjectHandle* self );
+    RimcWellEventTimeline_addSegmentEvent( caf::PdmObjectHandle* self );
 
     std::expected<caf::PdmObjectHandle*, QString> execute() override;
     QString                                       classKeywordReturnedType() const override;