#6596 Rename from FractureModel to StimPlanModel.

ApplicationCode/Application/CMakeLists_files.cmake

@@ -19,7 +19,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RiaEclipseFileNameTools.h
 ${CMAKE_CURRENT_LIST_DIR}/RiaFeatureCommandContext.h
 ${CMAKE_CURRENT_LIST_DIR}/RiaStringListSerializer.h
 ${CMAKE_CURRENT_LIST_DIR}/RiaNncDefines.h
-${CMAKE_CURRENT_LIST_DIR}/RiaFractureModelDefines.h
+${CMAKE_CURRENT_LIST_DIR}/RiaStimPlanModelDefines.h
 )
 
 set (SOURCE_GROUP_SOURCE_FILES
@@ -43,7 +43,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RiaEclipseFileNameTools.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RiaFeatureCommandContext.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RiaStringListSerializer.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RiaNncDefines.cpp
-${CMAKE_CURRENT_LIST_DIR}/RiaFractureModelDefines.cpp
+${CMAKE_CURRENT_LIST_DIR}/RiaStimPlanModelDefines.cpp
 )
 
 list(APPEND CODE_HEADER_FILES

ApplicationCode/Application/RiaApplication.cpp

@@ -53,10 +53,6 @@
 #include "RimEclipseView.h"
 #include "RimFlowPlotCollection.h"
 #include "RimFormationNamesCollection.h"
-#include "RimFractureModel.h"
-#include "RimFractureModelCollection.h"
-#include "RimFractureModelPlot.h"
-#include "RimFractureModelPlotCollection.h"
 #include "RimFractureTemplateCollection.h"
 #include "RimGeoMechCase.h"
 #include "RimGeoMechCellColors.h"
@@ -80,6 +76,10 @@
 #include "RimSaturationPressurePlotCollection.h"
 #include "RimSimWellInViewCollection.h"
 #include "RimStimPlanColors.h"
+#include "RimStimPlanModel.h"
+#include "RimStimPlanModelCollection.h"
+#include "RimStimPlanModelPlot.h"
+#include "RimStimPlanModelPlotCollection.h"
 #include "RimSummaryCase.h"
 #include "RimSummaryCaseCollection.h"
 #include "RimSummaryCaseMainCollection.h"
@@ -1575,7 +1575,7 @@ void RiaApplication::loadAndUpdatePlotData()
     RimAnalysisPlotCollection*           alsColl  = nullptr;
     RimCorrelationPlotCollection*        corrColl = nullptr;
     RimMultiPlotCollection*              gpwColl  = nullptr;
-    RimFractureModelPlotCollection*      frmColl  = nullptr;
+    RimStimPlanModelPlotCollection*      frmColl  = nullptr;
 
     if ( m_project->mainPlotCollection() )
     {
@@ -1623,9 +1623,9 @@ void RiaApplication::loadAndUpdatePlotData()
         {
             gpwColl = m_project->mainPlotCollection()->multiPlotCollection();
         }
-        if ( m_project->mainPlotCollection()->fractureModelPlotCollection() )
+        if ( m_project->mainPlotCollection()->stimPlanModelPlotCollection() )
         {
-            frmColl = m_project->mainPlotCollection()->fractureModelPlotCollection();
+            frmColl = m_project->mainPlotCollection()->stimPlanModelPlotCollection();
         }
     }
 
@@ -1641,7 +1641,7 @@ void RiaApplication::loadAndUpdatePlotData()
     plotCount += alsColl ? alsColl->plotCount() : 0;
     plotCount += corrColl ? corrColl->plotCount() + corrColl->reports().size() : 0;
     plotCount += gpwColl ? gpwColl->multiPlots().size() : 0;
-    plotCount += frmColl ? frmColl->fractureModelPlots().size() : 0;
+    plotCount += frmColl ? frmColl->stimPlanModelPlots().size() : 0;
 
     if ( plotCount > 0 )
     {
@@ -1750,9 +1750,9 @@ void RiaApplication::loadAndUpdatePlotData()
 
         if ( frmColl )
         {
-            for ( const auto& fractureModelPlot : frmColl->fractureModelPlots() )
+            for ( const auto& stimPlanModelPlot : frmColl->stimPlanModelPlots() )
             {
-                fractureModelPlot->loadDataAndUpdate();
+                stimPlanModelPlot->loadDataAndUpdate();
                 plotProgress.incrementProgress();
             }
         }

ApplicationCode/Application/RiaStimPlanModelDefines.cpp

@@ -16,7 +16,7 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 namespace caf
 {

ApplicationCode/Commands/CMakeLists_files.cmake

@@ -88,7 +88,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RicDeleteTemporaryLgrsFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicExportContourMapToTextFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicExportContourMapToTextUi.h
 ${CMAKE_CURRENT_LIST_DIR}/RicNewMultiPlotFeature.h
-${CMAKE_CURRENT_LIST_DIR}/RicExportFractureModelToFileFeature.h
+${CMAKE_CURRENT_LIST_DIR}/RicExportStimPlanModelToFileFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicStackSelectedCurvesFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicUnstackSelectedCurvesFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicThemeColorEditorFeature.h
@@ -184,7 +184,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RicDeleteTemporaryLgrsFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicExportContourMapToTextFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicExportContourMapToTextUi.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicNewMultiPlotFeature.cpp
-${CMAKE_CURRENT_LIST_DIR}/RicExportFractureModelToFileFeature.cpp
+${CMAKE_CURRENT_LIST_DIR}/RicExportStimPlanModelToFileFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicStackSelectedCurvesFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicUnstackSelectedCurvesFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicThemeColorEditorFeature.cpp

ApplicationCode/Commands/CompletionCommands/CMakeLists_files.cmake

@@ -12,7 +12,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RicNewValveAtMeasuredDepthFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicDeleteValveTemplateFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicWellPathImportCompletionsFileFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicWellPathImportPerforationIntervalsFeature.h
-${CMAKE_CURRENT_LIST_DIR}/RicNewFractureModelPlotFeature.h
+${CMAKE_CURRENT_LIST_DIR}/RicNewStimPlanModelPlotFeature.h
 )
 
 set (SOURCE_GROUP_SOURCE_FILES
@@ -28,7 +28,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RicNewValveAtMeasuredDepthFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicDeleteValveTemplateFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicWellPathImportCompletionsFileFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicWellPathImportPerforationIntervalsFeature.cpp
-${CMAKE_CURRENT_LIST_DIR}/RicNewFractureModelPlotFeature.cpp
+${CMAKE_CURRENT_LIST_DIR}/RicNewStimPlanModelPlotFeature.cpp
 )
 
 

ApplicationCode/Commands/CompletionCommands/RicNewStimPlanModelPlotFeature.cpp

@@ -16,7 +16,7 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RicNewFractureModelPlotFeature.h"
+#include "RicNewStimPlanModelPlotFeature.h"
 
 #include "RiaApplication.h"
 #include "RiaColorTables.h"
@@ -33,14 +33,14 @@
 #include "RimEclipseResultDefinition.h"
 #include "RimEclipseView.h"
 #include "RimFaciesProperties.h"
-#include "RimFractureModel.h"
-#include "RimFractureModelCurve.h"
-#include "RimFractureModelPlot.h"
-#include "RimFractureModelPlotCollection.h"
-#include "RimFractureModelTemplate.h"
 #include "RimMainPlotCollection.h"
 #include "RimModeledWellPath.h"
 #include "RimProject.h"
+#include "RimStimPlanModel.h"
+#include "RimStimPlanModelCurve.h"
+#include "RimStimPlanModelPlot.h"
+#include "RimStimPlanModelPlotCollection.h"
+#include "RimStimPlanModelTemplate.h"
 #include "RimWellLogTrack.h"
 #include "RimWellPath.h"
 #include "RimWellPathCollection.h"
@@ -59,35 +59,35 @@
 #include <algorithm>
 #include <set>
 
-CAF_CMD_SOURCE_INIT( RicNewFractureModelPlotFeature, "RicNewFractureModelPlotFeature" );
+CAF_CMD_SOURCE_INIT( RicNewStimPlanModelPlotFeature, "RicNewStimPlanModelPlotFeature" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelPlot* RicNewFractureModelPlotFeature::createPlot( RimFractureModel* fractureModel )
+RimStimPlanModelPlot* RicNewStimPlanModelPlotFeature::createPlot( RimStimPlanModel* stimPlanModel )
 
 {
-    RimEclipseCase* eclipseCase = fractureModel->eclipseCase();
+    RimEclipseCase* eclipseCase = stimPlanModel->eclipseCase();
-    int             timeStep    = fractureModel->timeStep();
+    int             timeStep    = stimPlanModel->timeStep();
 
-    caf::ProgressInfo progInfo( 100, "Creating Fracture Model Plot" );
+    caf::ProgressInfo progInfo( 100, "Creating StimPlan Model Plot" );
 
-    RimFractureModelPlot* plot = createFractureModelPlot( true, "Fracture Model" );
+    RimStimPlanModelPlot* plot = createStimPlanModelPlot( true, "StimPlan Model" );
-    plot->setFractureModel( fractureModel );
+    plot->setStimPlanModel( stimPlanModel );
 
     {
         auto task = progInfo.task( "Creating formation track", 2 );
-        createFormationTrack( plot, fractureModel, eclipseCase );
+        createFormationTrack( plot, stimPlanModel, eclipseCase );
     }
 
     {
         auto task = progInfo.task( "Creating facies track", 2 );
-        createFaciesTrack( plot, fractureModel, eclipseCase );
+        createFaciesTrack( plot, stimPlanModel, eclipseCase );
     }
 
     {
         auto task = progInfo.task( "Creating layers track", 2 );
-        createLayersTrack( plot, fractureModel, eclipseCase );
+        createLayersTrack( plot, stimPlanModel, eclipseCase );
     }
 
     {
@@ -105,20 +105,20 @@ RimFractureModelPlot* RicNewFractureModelPlotFeature::createPlot( RimFractureMod
         for ( auto result : plots )
         {
             bool logarithmicPlot = logarithmicPlots.count( result.first ) > 0;
-            createParametersTrack( plot, fractureModel, eclipseCase, timeStep, result.first, result.second, logarithmicPlot );
+            createParametersTrack( plot, stimPlanModel, eclipseCase, timeStep, result.first, result.second, logarithmicPlot );
         }
     }
 
     {
         auto task = progInfo.task( "Creating stress track", 2 );
         createParametersTrack( plot,
-                               fractureModel,
+                               stimPlanModel,
                                eclipseCase,
                                timeStep,
                                "Stress",
                                {RiaDefines::CurveProperty::STRESS, RiaDefines::CurveProperty::INITIAL_STRESS} );
         createParametersTrack( plot,
-                               fractureModel,
+                               stimPlanModel,
                                eclipseCase,
                                timeStep,
                                "Stress Gradient",
@@ -144,13 +144,13 @@ RimFractureModelPlot* RicNewFractureModelPlotFeature::createPlot( RimFractureMod
         for ( auto result : results )
         {
             QString trackName = caf::AppEnum<RiaDefines::CurveProperty>::uiText( result );
-            createParametersTrack( plot, fractureModel, eclipseCase, timeStep, trackName, {result} );
+            createParametersTrack( plot, stimPlanModel, eclipseCase, timeStep, trackName, {result} );
         }
     }
 
     {
         auto task = progInfo.task( "Creating temperature track", 2 );
-        createParametersTrack( plot, fractureModel, eclipseCase, timeStep, "Temperature", {RiaDefines::CurveProperty::TEMPERATURE} );
+        createParametersTrack( plot, stimPlanModel, eclipseCase, timeStep, "Temperature", {RiaDefines::CurveProperty::TEMPERATURE} );
     }
 
     {
@@ -177,7 +177,7 @@ RimFractureModelPlot* RicNewFractureModelPlotFeature::createPlot( RimFractureMod
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RicNewFractureModelPlotFeature::isCommandEnabled()
+bool RicNewStimPlanModelPlotFeature::isCommandEnabled()
 {
     Rim3dView* view = RiaApplication::instance()->activeReservoirView();
     if ( !view ) return false;
@@ -188,37 +188,37 @@ bool RicNewFractureModelPlotFeature::isCommandEnabled()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewFractureModelPlotFeature::onActionTriggered( bool isChecked )
+void RicNewStimPlanModelPlotFeature::onActionTriggered( bool isChecked )
 {
-    RimFractureModel* fractureModel = caf::SelectionManager::instance()->selectedItemAncestorOfType<RimFractureModel>();
+    RimStimPlanModel* stimPlanModel = caf::SelectionManager::instance()->selectedItemAncestorOfType<RimStimPlanModel>();
-    if ( !fractureModel ) return;
+    if ( !stimPlanModel ) return;
 
-    createPlot( fractureModel );
+    createPlot( stimPlanModel );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewFractureModelPlotFeature::setupActionLook( QAction* actionToSetup )
+void RicNewStimPlanModelPlotFeature::setupActionLook( QAction* actionToSetup )
 {
-    actionToSetup->setText( "New Fracture Model Plot" );
+    actionToSetup->setText( "New StimPlan Model Plot" );
     // actionToSetup->setIcon( QIcon( ":/WellBoreStability16x16.png" ) );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewFractureModelPlotFeature::createFormationTrack( RimFractureModelPlot* plot,
+void RicNewStimPlanModelPlotFeature::createFormationTrack( RimStimPlanModelPlot* plot,
-                                                           RimFractureModel*     fractureModel,
+                                                           RimStimPlanModel*     stimPlanModel,
                                                            RimEclipseCase*       eclipseCase )
 {
     RimWellLogTrack* formationTrack = RicNewWellLogPlotFeatureImpl::createWellLogPlotTrack( false, "Formations", plot );
-    formationTrack->setFormationWellPath( fractureModel->thicknessDirectionWellPath() );
+    formationTrack->setFormationWellPath( stimPlanModel->thicknessDirectionWellPath() );
     formationTrack->setFormationCase( eclipseCase );
     formationTrack->setAnnotationType( RiuPlotAnnotationTool::RegionAnnotationType::FORMATION_ANNOTATIONS );
     formationTrack->setVisibleXRange( 0.0, 0.0 );
-    formationTrack->setOverburdenHeight( fractureModel->overburdenHeight() );
+    formationTrack->setOverburdenHeight( stimPlanModel->overburdenHeight() );
-    formationTrack->setUnderburdenHeight( fractureModel->underburdenHeight() );
+    formationTrack->setUnderburdenHeight( stimPlanModel->underburdenHeight() );
     formationTrack->setColSpan( RimPlot::ONE );
     formationTrack->setLegendsVisible( true );
 }
@@ -226,26 +226,26 @@ void RicNewFractureModelPlotFeature::createFormationTrack( RimFractureModelPlot*
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewFractureModelPlotFeature::createFaciesTrack( RimFractureModelPlot* plot,
+void RicNewStimPlanModelPlotFeature::createFaciesTrack( RimStimPlanModelPlot* plot,
-                                                        RimFractureModel*     fractureModel,
+                                                        RimStimPlanModel*     stimPlanModel,
                                                         RimEclipseCase*       eclipseCase )
 {
-    RimFractureModelTemplate* fractureModelTemplate = fractureModel->fractureModelTemplate();
+    RimStimPlanModelTemplate* stimPlanModelTemplate = stimPlanModel->stimPlanModelTemplate();
-    if ( !fractureModelTemplate ) return;
+    if ( !stimPlanModelTemplate ) return;
 
-    RimFaciesProperties* faciesProperties = fractureModelTemplate->faciesProperties();
+    RimFaciesProperties* faciesProperties = stimPlanModelTemplate->faciesProperties();
     if ( !faciesProperties ) return;
 
     const RimEclipseResultDefinition* faciesDefinition = faciesProperties->faciesDefinition();
     if ( !faciesDefinition ) return;
 
     RimWellLogTrack* faciesTrack = RicNewWellLogPlotFeatureImpl::createWellLogPlotTrack( false, "Facies", plot );
-    faciesTrack->setFormationWellPath( fractureModel->thicknessDirectionWellPath() );
+    faciesTrack->setFormationWellPath( stimPlanModel->thicknessDirectionWellPath() );
     faciesTrack->setFormationCase( eclipseCase );
     faciesTrack->setAnnotationType( RiuPlotAnnotationTool::RegionAnnotationType::RESULT_PROPERTY_ANNOTATIONS );
     faciesTrack->setRegionPropertyResultType( faciesDefinition->resultType(), faciesDefinition->resultVariable() );
-    faciesTrack->setOverburdenHeight( fractureModel->overburdenHeight() );
+    faciesTrack->setOverburdenHeight( stimPlanModel->overburdenHeight() );
-    faciesTrack->setUnderburdenHeight( fractureModel->underburdenHeight() );
+    faciesTrack->setUnderburdenHeight( stimPlanModel->underburdenHeight() );
     faciesTrack->setLegendsVisible( true );
     faciesTrack->setPlotTitleVisible( true );
 
@@ -257,8 +257,8 @@ void RicNewFractureModelPlotFeature::createFaciesTrack( RimFractureModelPlot* pl
 
     caf::ColorTable colors = RiaColorTables::wellLogPlotPaletteColors();
 
-    RimFractureModelCurve* curve = new RimFractureModelCurve;
+    RimStimPlanModelCurve* curve = new RimStimPlanModelCurve;
-    curve->setFractureModel( fractureModel );
+    curve->setStimPlanModel( stimPlanModel );
     curve->setCurveProperty( RiaDefines::CurveProperty::FACIES );
     curve->setCase( eclipseCase );
     curve->setEclipseResultCategory( faciesDefinition->resultType() );
@@ -286,20 +286,20 @@ void RicNewFractureModelPlotFeature::createFaciesTrack( RimFractureModelPlot* pl
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewFractureModelPlotFeature::createLayersTrack( RimFractureModelPlot* plot,
+void RicNewStimPlanModelPlotFeature::createLayersTrack( RimStimPlanModelPlot* plot,
-                                                        RimFractureModel*     fractureModel,
+                                                        RimStimPlanModel*     stimPlanModel,
                                                         RimEclipseCase*       eclipseCase )
 {
     RimWellLogTrack* faciesTrack = RicNewWellLogPlotFeatureImpl::createWellLogPlotTrack( false, "Layers", plot );
-    faciesTrack->setFormationWellPath( fractureModel->thicknessDirectionWellPath() );
+    faciesTrack->setFormationWellPath( stimPlanModel->thicknessDirectionWellPath() );
     faciesTrack->setFormationCase( eclipseCase );
     faciesTrack->setLegendsVisible( true );
     faciesTrack->setPlotTitleVisible( true );
 
-    RimFractureModelTemplate* fractureModelTemplate = fractureModel->fractureModelTemplate();
+    RimStimPlanModelTemplate* stimPlanModelTemplate = stimPlanModel->stimPlanModelTemplate();
-    if ( !fractureModelTemplate ) return;
+    if ( !stimPlanModelTemplate ) return;
 
-    RimFaciesProperties* faciesProperties = fractureModelTemplate->faciesProperties();
+    RimFaciesProperties* faciesProperties = stimPlanModelTemplate->faciesProperties();
     if ( !faciesProperties ) return;
 
     RimColorLegend* faciesColors = faciesProperties->colorLegend();
@@ -310,9 +310,9 @@ void RicNewFractureModelPlotFeature::createLayersTrack( RimFractureModelPlot* pl
 
     caf::ColorTable colors = RiaColorTables::wellLogPlotPaletteColors();
 
-    RimFractureModelCurve* curve = new RimFractureModelCurve;
+    RimStimPlanModelCurve* curve = new RimStimPlanModelCurve;
     curve->setCurveProperty( RiaDefines::CurveProperty::LAYERS );
-    curve->setFractureModel( fractureModel );
+    curve->setStimPlanModel( stimPlanModel );
     curve->setCase( eclipseCase );
     curve->setColor( colors.cycledColor3f( 0 ) );
     curve->setLineStyle( RiuQwtPlotCurve::STYLE_SOLID );
@@ -337,8 +337,8 @@ void RicNewFractureModelPlotFeature::createLayersTrack( RimFractureModelPlot* pl
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewFractureModelPlotFeature::createParametersTrack( RimFractureModelPlot*                         plot,
+void RicNewStimPlanModelPlotFeature::createParametersTrack( RimStimPlanModelPlot*                         plot,
-                                                            RimFractureModel*                             fractureModel,
+                                                            RimStimPlanModel*                             stimPlanModel,
                                                             RimEclipseCase*                               eclipseCase,
                                                             int                                           timeStep,
                                                             const QString&                                trackTitle,
@@ -347,7 +347,7 @@ void RicNewFractureModelPlotFeature::createParametersTrack( RimFractureModelPlot
 {
     RimWellLogTrack* plotTrack = RicNewWellLogPlotFeatureImpl::createWellLogPlotTrack( false, trackTitle, plot );
     plotTrack->setFormationCase( eclipseCase );
-    plotTrack->setFormationWellPath( fractureModel->thicknessDirectionWellPath() );
+    plotTrack->setFormationWellPath( stimPlanModel->thicknessDirectionWellPath() );
     plotTrack->setColSpan( RimPlot::TWO );
     plotTrack->setLegendsVisible( true );
     plotTrack->setPlotTitleVisible( true );
@@ -357,14 +357,14 @@ void RicNewFractureModelPlotFeature::createParametersTrack( RimFractureModelPlot
     int colorIndex = 0;
     for ( const RiaDefines::CurveProperty& propertyType : propertyTypes )
     {
-        QString                   resultVariable     = fractureModel->eclipseResultVariable( propertyType );
+        QString                   resultVariable     = stimPlanModel->eclipseResultVariable( propertyType );
-        RiaDefines::ResultCatType resultCategoryType = fractureModel->eclipseResultCategory( propertyType );
+        RiaDefines::ResultCatType resultCategoryType = stimPlanModel->eclipseResultCategory( propertyType );
         // TODO: maybe improve?
         bool fixedInitialTimeStep = ( propertyType == RiaDefines::CurveProperty::INITIAL_PRESSURE );
 
-        RimFractureModelCurve* curve = new RimFractureModelCurve;
+        RimStimPlanModelCurve* curve = new RimStimPlanModelCurve;
         curve->setCurveProperty( propertyType );
-        curve->setFractureModel( fractureModel );
+        curve->setStimPlanModel( stimPlanModel );
         curve->setCase( eclipseCase );
         curve->setEclipseResultVariable( resultVariable );
         curve->setEclipseResultCategory( resultCategoryType );
@@ -413,20 +413,20 @@ void RicNewFractureModelPlotFeature::createParametersTrack( RimFractureModelPlot
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelPlot* RicNewFractureModelPlotFeature::createFractureModelPlot( bool           showAfterCreation,
+RimStimPlanModelPlot* RicNewStimPlanModelPlotFeature::createStimPlanModelPlot( bool           showAfterCreation,
                                                                                const QString& plotDescription )
 
 {
-    RimFractureModelPlotCollection* fractureModelPlotColl = fractureModelPlotCollection();
+    RimStimPlanModelPlotCollection* stimPlanModelPlotColl = stimPlanModelPlotCollection();
-    CVF_ASSERT( fractureModelPlotColl );
+    CVF_ASSERT( stimPlanModelPlotColl );
 
     // Make sure the summary plot window is created
     RiaGuiApplication::instance()->getOrCreateMainPlotWindow();
 
-    RimFractureModelPlot* plot = new RimFractureModelPlot();
+    RimStimPlanModelPlot* plot = new RimStimPlanModelPlot();
     plot->setAsPlotMdiWindow();
 
-    fractureModelPlotColl->addFractureModelPlot( plot );
+    stimPlanModelPlotColl->addStimPlanModelPlot( plot );
 
     if ( !plotDescription.isEmpty() )
     {
@@ -435,7 +435,7 @@ RimFractureModelPlot* RicNewFractureModelPlotFeature::createFractureModelPlot( b
     else
     {
         plot->nameConfig()->setCustomName(
-            QString( "Fracture Model Plot %1" ).arg( fractureModelPlotCollection()->fractureModelPlots().size() ) );
+            QString( "StimPlan Model Plot %1" ).arg( stimPlanModelPlotCollection()->stimPlanModelPlots().size() ) );
     }
 
     if ( showAfterCreation )
@@ -449,7 +449,7 @@ RimFractureModelPlot* RicNewFractureModelPlotFeature::createFractureModelPlot( b
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelPlotCollection* RicNewFractureModelPlotFeature::fractureModelPlotCollection()
+RimStimPlanModelPlotCollection* RicNewStimPlanModelPlotFeature::stimPlanModelPlotCollection()
 {
     RimProject* project = RiaApplication::instance()->project();
     CVF_ASSERT( project );
@@ -457,8 +457,8 @@ RimFractureModelPlotCollection* RicNewFractureModelPlotFeature::fractureModelPlo
     RimMainPlotCollection* mainPlotColl = project->mainPlotCollection();
     CVF_ASSERT( mainPlotColl );
 
-    RimFractureModelPlotCollection* fractureModelPlotColl = mainPlotColl->fractureModelPlotCollection();
+    RimStimPlanModelPlotCollection* stimPlanModelPlotColl = mainPlotColl->stimPlanModelPlotCollection();
-    CVF_ASSERT( fractureModelPlotColl );
+    CVF_ASSERT( stimPlanModelPlotColl );
 
-    return mainPlotColl->fractureModelPlotCollection();
+    return mainPlotColl->stimPlanModelPlotCollection();
 }

ApplicationCode/Commands/CompletionCommands/RicNewStimPlanModelPlotFeature.h

@@ -21,22 +21,22 @@
 #include "cafCmdFeature.h"
 
 #include "RiaDefines.h"
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 class RimEclipseCase;
-class RimFractureModelPlot;
+class RimStimPlanModelPlot;
-class RimFractureModelPlotCollection;
+class RimStimPlanModelPlotCollection;
-class RimFractureModel;
+class RimStimPlanModel;
 
 //==================================================================================================
 ///
 //==================================================================================================
-class RicNewFractureModelPlotFeature : public caf::CmdFeature
+class RicNewStimPlanModelPlotFeature : public caf::CmdFeature
 {
     CAF_CMD_HEADER_INIT;
 
 public:
-    static RimFractureModelPlot* createPlot( RimFractureModel* fractureModel );
+    static RimStimPlanModelPlot* createPlot( RimStimPlanModel* stimPlanModel );
 
 protected:
     // Overrides
@@ -46,21 +46,21 @@ protected:
 
 private:
     static void
-        createFormationTrack( RimFractureModelPlot* plot, RimFractureModel* fractureModel, RimEclipseCase* eclipseCase );
+        createFormationTrack( RimStimPlanModelPlot* plot, RimStimPlanModel* stimPlanModel, RimEclipseCase* eclipseCase );
     static void
-        createFaciesTrack( RimFractureModelPlot* plot, RimFractureModel* fractureModel, RimEclipseCase* eclipseCase );
+        createFaciesTrack( RimStimPlanModelPlot* plot, RimStimPlanModel* stimPlanModel, RimEclipseCase* eclipseCase );
     static void
-        createLayersTrack( RimFractureModelPlot* plot, RimFractureModel* fractureModel, RimEclipseCase* eclipseCase );
+        createLayersTrack( RimStimPlanModelPlot* plot, RimStimPlanModel* stimPlanModel, RimEclipseCase* eclipseCase );
 
-    static void createParametersTrack( RimFractureModelPlot*                         plot,
+    static void createParametersTrack( RimStimPlanModelPlot*                         plot,
-                                       RimFractureModel*                             fractureModel,
+                                       RimStimPlanModel*                             stimPlanModel,
                                        RimEclipseCase*                               eclipseCase,
                                        int                                           timeStep,
                                        const QString&                                trackTitle,
                                        const std::vector<RiaDefines::CurveProperty>& propertyTypes,
                                        bool                                          isPlotLogarithmic = false );
 
-    static RimFractureModelPlot* createFractureModelPlot( bool showAfterCreation, const QString& plotDescription );
+    static RimStimPlanModelPlot* createStimPlanModelPlot( bool showAfterCreation, const QString& plotDescription );
 
-    static RimFractureModelPlotCollection* fractureModelPlotCollection();
+    static RimStimPlanModelPlotCollection* stimPlanModelPlotCollection();
 };

ApplicationCode/Commands/FractureCommands/CMakeLists_files.cmake

@@ -12,9 +12,9 @@ ${CMAKE_CURRENT_LIST_DIR}/RicNewSimWellFractureFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicNewStimPlanFractureTemplateFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicNewWellPathFractureAtPosFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicNewWellPathFractureFeature.h
-${CMAKE_CURRENT_LIST_DIR}/RicNewFractureModelFeature.h
+${CMAKE_CURRENT_LIST_DIR}/RicNewStimPlanModelFeature.h
-${CMAKE_CURRENT_LIST_DIR}/RicNewWellPathFractureModelAtPosFeature.h
+${CMAKE_CURRENT_LIST_DIR}/RicNewWellPathStimPlanModelAtPosFeature.h
-${CMAKE_CURRENT_LIST_DIR}/RicNewFractureModelTemplateFeature.h
+${CMAKE_CURRENT_LIST_DIR}/RicNewStimPlanModelTemplateFeature.h
 ${CMAKE_CURRENT_LIST_DIR}/RicNewElasticPropertyScalingFeature.h
 
 ${CMAKE_CURRENT_LIST_DIR}/RicCreateMultipleFracturesFeature.h
@@ -37,9 +37,9 @@ ${CMAKE_CURRENT_LIST_DIR}/RicNewSimWellFractureFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicNewStimPlanFractureTemplateFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicNewWellPathFractureAtPosFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicNewWellPathFractureFeature.cpp
-${CMAKE_CURRENT_LIST_DIR}/RicNewFractureModelFeature.cpp
+${CMAKE_CURRENT_LIST_DIR}/RicNewStimPlanModelFeature.cpp
-${CMAKE_CURRENT_LIST_DIR}/RicNewWellPathFractureModelAtPosFeature.cpp
+${CMAKE_CURRENT_LIST_DIR}/RicNewWellPathStimPlanModelAtPosFeature.cpp
-${CMAKE_CURRENT_LIST_DIR}/RicNewFractureModelTemplateFeature.cpp
+${CMAKE_CURRENT_LIST_DIR}/RicNewStimPlanModelTemplateFeature.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RicNewElasticPropertyScalingFeature.cpp
 
 ${CMAKE_CURRENT_LIST_DIR}/RicCreateMultipleFracturesFeature.cpp

ApplicationCode/Commands/FractureCommands/RicFractureNameGenerator.cpp

@@ -19,8 +19,8 @@
 #include "RicFractureNameGenerator.h"
 
 #include "RimFracture.h"
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
-#include "RimFractureModelTemplate.h"
+#include "RimStimPlanModelTemplate.h"
 
 //--------------------------------------------------------------------------------------------------
 ///
@@ -33,15 +33,15 @@ QString RicFractureNameGenerator::nameForNewFracture()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RicFractureNameGenerator::nameForNewFractureModel()
+QString RicFractureNameGenerator::nameForNewStimPlanModel()
 {
-    return RicFractureNameGenerator::nameForNewObject<RimFractureModel>( "Fracture Model_%1" );
+    return RicFractureNameGenerator::nameForNewObject<RimStimPlanModel>( "StimPlan Model_%1" );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RicFractureNameGenerator::nameForNewFractureModelTemplate()
+QString RicFractureNameGenerator::nameForNewStimPlanModelTemplate()
 {
-    return RicFractureNameGenerator::nameForNewObject<RimFractureModelTemplate>( "Fracture Model Template_%1" );
+    return RicFractureNameGenerator::nameForNewObject<RimStimPlanModelTemplate>( "StimPlan Model Template_%1" );
 }

ApplicationCode/Commands/FractureCommands/RicFractureNameGenerator.h

@@ -30,8 +30,8 @@ class RicFractureNameGenerator
 {
 public:
     static QString nameForNewFracture();
-    static QString nameForNewFractureModel();
+    static QString nameForNewStimPlanModel();
-    static QString nameForNewFractureModelTemplate();
+    static QString nameForNewStimPlanModelTemplate();
 
 private:
     template <typename T>

ApplicationCode/Commands/FractureCommands/RicNewStimPlanModelFeature.cpp

@@ -16,18 +16,18 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RicNewFractureModelFeature.h"
+#include "RicNewStimPlanModelFeature.h"
 
 #include "RiaApplication.h"
 
 #include "RicFractureNameGenerator.h"
 
 #include "RimEclipseView.h"
-#include "RimFractureModel.h"
-#include "RimFractureModelCollection.h"
 #include "RimModeledWellPath.h"
 #include "RimOilField.h"
 #include "RimProject.h"
+#include "RimStimPlanModel.h"
+#include "RimStimPlanModelCollection.h"
 #include "RimWellPath.h"
 #include "RimWellPathCollection.h"
 #include "RimWellPathCompletions.h"
@@ -42,12 +42,12 @@
 
 #include <QAction>
 
-CAF_CMD_SOURCE_INIT( RicNewFractureModelFeature, "RicNewFractureModelFeature" );
+CAF_CMD_SOURCE_INIT( RicNewStimPlanModelFeature, "RicNewStimPlanModelFeature" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModel* RicNewFractureModelFeature::addFractureModel( RimWellPath*           wellPath,
+RimStimPlanModel* RicNewStimPlanModelFeature::addStimPlanModel( RimWellPath*           wellPath,
                                                                 RimWellPathCollection* wellPathCollection,
                                                                 RimEclipseCase*        eclipseCase,
                                                                 int                    timeStep,
@@ -57,28 +57,28 @@ RimFractureModel* RicNewFractureModelFeature::addFractureModel( RimWellPath*
 
     if ( !RicWellPathsUnitSystemSettingsImpl::ensureHasUnitSystem( wellPath ) ) return nullptr;
 
-    RimFractureModelCollection* fractureModelCollection = wellPath->fractureModelCollection();
+    RimStimPlanModelCollection* stimPlanModelCollection = wellPath->stimPlanModelCollection();
-    CVF_ASSERT( fractureModelCollection );
+    CVF_ASSERT( stimPlanModelCollection );
 
     RimOilField* oilfield = nullptr;
-    fractureModelCollection->firstAncestorOrThisOfType( oilfield );
+    stimPlanModelCollection->firstAncestorOrThisOfType( oilfield );
     if ( !oilfield ) return nullptr;
 
-    RimFractureModel* fractureModel = new RimFractureModel();
+    RimStimPlanModel* stimPlanModel = new RimStimPlanModel();
-    fractureModelCollection->addFractureModel( fractureModel );
+    stimPlanModelCollection->addStimPlanModel( stimPlanModel );
 
-    fractureModel->setEclipseCase( eclipseCase );
+    stimPlanModel->setEclipseCase( eclipseCase );
-    fractureModel->setTimeStep( timeStep );
+    stimPlanModel->setTimeStep( timeStep );
 
-    QString fractureModelName = RicFractureNameGenerator::nameForNewFractureModel();
+    QString stimPlanModelName = RicFractureNameGenerator::nameForNewStimPlanModel();
-    fractureModel->setName( fractureModelName );
+    stimPlanModel->setName( stimPlanModelName );
 
     RimProject* project = nullptr;
-    fractureModelCollection->firstAncestorOrThisOfType( project );
+    stimPlanModelCollection->firstAncestorOrThisOfType( project );
 
     // Add a "fake" well path for thickess direction
     RimModeledWellPath* thicknessDirectionWellPath = new RimModeledWellPath;
-    fractureModel->setThicknessDirectionWellPath( thicknessDirectionWellPath );
+    stimPlanModel->setThicknessDirectionWellPath( thicknessDirectionWellPath );
 
     std::vector<RimWellPath*> wellPaths = {thicknessDirectionWellPath};
     wellPathCollection->addWellPaths( wellPaths, false );
@@ -91,19 +91,19 @@ RimFractureModel* RicNewFractureModelFeature::addFractureModel( RimWellPath*
 
     if ( measuredDepth > 0.0 )
     {
-        fractureModel->setMD( measuredDepth );
+        stimPlanModel->setMD( measuredDepth );
     }
 
-    Riu3DMainWindowTools::selectAsCurrentItem( fractureModel );
+    Riu3DMainWindowTools::selectAsCurrentItem( stimPlanModel );
-    return fractureModel;
+    return stimPlanModel;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewFractureModelFeature::onActionTriggered( bool isChecked )
+void RicNewStimPlanModelFeature::onActionTriggered( bool isChecked )
 {
-    RimFractureModelCollection* fractureColl = RicNewFractureModelFeature::selectedFractureModelCollection();
+    RimStimPlanModelCollection* fractureColl = RicNewStimPlanModelFeature::selectedStimPlanModelCollection();
     if ( !fractureColl ) return;
 
     RimWellPath* wellPath = nullptr;
@@ -121,30 +121,30 @@ void RicNewFractureModelFeature::onActionTriggered( bool isChecked )
         timeStep    = activeView->currentTimeStep();
     }
 
-    RicNewFractureModelFeature::addFractureModel( wellPath, wellPathCollection, eclipseCase, timeStep );
+    RicNewStimPlanModelFeature::addStimPlanModel( wellPath, wellPathCollection, eclipseCase, timeStep );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewFractureModelFeature::setupActionLook( QAction* actionToSetup )
+void RicNewStimPlanModelFeature::setupActionLook( QAction* actionToSetup )
 {
     actionToSetup->setIcon( QIcon( ":/FractureSymbol16x16.png" ) );
-    actionToSetup->setText( "Create Fracture Model" );
+    actionToSetup->setText( "Create StimPlan Model" );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RicNewFractureModelFeature::isCommandEnabled()
+bool RicNewStimPlanModelFeature::isCommandEnabled()
 {
-    return selectedFractureModelCollection() != nullptr;
+    return selectedStimPlanModelCollection() != nullptr;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelCollection* RicNewFractureModelFeature::selectedFractureModelCollection()
+RimStimPlanModelCollection* RicNewStimPlanModelFeature::selectedStimPlanModelCollection()
 {
     std::vector<caf::PdmUiItem*> selectedItems;
     caf::SelectionManager::instance()->selectedItems( selectedItems );
@@ -152,20 +152,20 @@ RimFractureModelCollection* RicNewFractureModelFeature::selectedFractureModelCol
 
     caf::PdmUiItem* pdmUiItem = selectedItems.front();
 
-    RimFractureModelCollection* fractureModelCollection = nullptr;
+    RimStimPlanModelCollection* stimPlanModelCollection = nullptr;
     caf::PdmObjectHandle*       objHandle               = dynamic_cast<caf::PdmObjectHandle*>( pdmUiItem );
     if ( objHandle )
     {
-        objHandle->firstAncestorOrThisOfType( fractureModelCollection );
+        objHandle->firstAncestorOrThisOfType( stimPlanModelCollection );
 
-        if ( fractureModelCollection ) return fractureModelCollection;
+        if ( stimPlanModelCollection ) return stimPlanModelCollection;
 
         RimWellPath* wellPath = dynamic_cast<RimWellPath*>( objHandle );
-        if ( wellPath ) return wellPath->fractureModelCollection();
+        if ( wellPath ) return wellPath->stimPlanModelCollection();
 
         RimWellPathCompletions* completions =
             caf::SelectionManager::instance()->selectedItemOfType<RimWellPathCompletions>();
-        if ( completions ) return completions->fractureModelCollection();
+        if ( completions ) return completions->stimPlanModelCollection();
     }
     return nullptr;
 }

ApplicationCode/Commands/FractureCommands/RicNewStimPlanModelFeature.h

@@ -20,8 +20,8 @@
 
 #include "cafCmdFeature.h"
 
-class RimFractureModel;
+class RimStimPlanModel;
-class RimFractureModelCollection;
+class RimStimPlanModelCollection;
 class RimWellPath;
 class RimWellPathCollection;
 class RimEclipseCase;
@@ -29,12 +29,12 @@ class RimEclipseCase;
 //==================================================================================================
 ///
 //==================================================================================================
-class RicNewFractureModelFeature : public caf::CmdFeature
+class RicNewStimPlanModelFeature : public caf::CmdFeature
 {
     CAF_CMD_HEADER_INIT;
 
 public:
-    static RimFractureModel* addFractureModel( RimWellPath*           wellPath,
+    static RimStimPlanModel* addStimPlanModel( RimWellPath*           wellPath,
                                                RimWellPathCollection* wellPathCollection,
                                                RimEclipseCase*        eclipseCase   = nullptr,
                                                int                    timeStep      = 0,
@@ -46,5 +46,5 @@ protected:
     bool isCommandEnabled() override;
 
 private:
-    static RimFractureModelCollection* selectedFractureModelCollection();
+    static RimStimPlanModelCollection* selectedStimPlanModelCollection();
 };

ApplicationCode/Commands/FractureCommands/RicNewStimPlanModelTemplateFeature.cpp

@@ -16,13 +16,13 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RicNewFractureModelTemplateFeature.h"
+#include "RicNewStimPlanModelTemplateFeature.h"
 
 #include "RimCompletionTemplateCollection.h"
-#include "RimFractureModelTemplate.h"
-#include "RimFractureModelTemplateCollection.h"
 #include "RimOilField.h"
 #include "RimProject.h"
+#include "RimStimPlanModelTemplate.h"
+#include "RimStimPlanModelTemplateCollection.h"
 
 #include "RicFractureNameGenerator.h"
 
@@ -34,12 +34,12 @@
 
 #include <QAction>
 
-CAF_CMD_SOURCE_INIT( RicNewFractureModelTemplateFeature, "RicNewFractureModelTemplateFeature" );
+CAF_CMD_SOURCE_INIT( RicNewStimPlanModelTemplateFeature, "RicNewStimPlanModelTemplateFeature" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewFractureModelTemplateFeature::onActionTriggered( bool isChecked )
+void RicNewStimPlanModelTemplateFeature::onActionTriggered( bool isChecked )
 {
     RimProject* project = RimProject::current();
     CVF_ASSERT( project );
@@ -47,31 +47,31 @@ void RicNewFractureModelTemplateFeature::onActionTriggered( bool isChecked )
     RimOilField* oilfield = project->activeOilField();
     if ( !oilfield ) return;
 
-    RimFractureModelTemplateCollection* fracModColl =
+    RimStimPlanModelTemplateCollection* fracModColl =
-        oilfield->completionTemplateCollection->fractureModelTemplateCollection();
+        oilfield->completionTemplateCollection->stimPlanModelTemplateCollection();
     if ( !fracModColl ) return;
 
-    RimFractureModelTemplate* fractureModelTemplate = new RimFractureModelTemplate;
+    RimStimPlanModelTemplate* stimPlanModelTemplate = new RimStimPlanModelTemplate;
-    fractureModelTemplate->setName( RicFractureNameGenerator::nameForNewFractureModelTemplate() );
+    stimPlanModelTemplate->setName( RicFractureNameGenerator::nameForNewStimPlanModelTemplate() );
 
-    fracModColl->addFractureModelTemplate( fractureModelTemplate );
+    fracModColl->addStimPlanModelTemplate( stimPlanModelTemplate );
     fracModColl->updateConnectedEditors();
-    Riu3DMainWindowTools::selectAsCurrentItem( fractureModelTemplate );
+    Riu3DMainWindowTools::selectAsCurrentItem( stimPlanModelTemplate );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewFractureModelTemplateFeature::setupActionLook( QAction* actionToSetup )
+void RicNewStimPlanModelTemplateFeature::setupActionLook( QAction* actionToSetup )
 {
     actionToSetup->setIcon( QIcon( ":/FractureTemplate16x16.png" ) );
-    actionToSetup->setText( "New Fracture Model Template" );
+    actionToSetup->setText( "New StimPlan Model Template" );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RicNewFractureModelTemplateFeature::isCommandEnabled()
+bool RicNewStimPlanModelTemplateFeature::isCommandEnabled()
 {
     return true;
 }

ApplicationCode/Commands/FractureCommands/RicNewStimPlanModelTemplateFeature.h

@@ -25,7 +25,7 @@
 //==================================================================================================
 ///
 //==================================================================================================
-class RicNewFractureModelTemplateFeature : public caf::CmdFeature
+class RicNewStimPlanModelTemplateFeature : public caf::CmdFeature
 {
     CAF_CMD_HEADER_INIT;
 

ApplicationCode/Commands/FractureCommands/RicNewWellPathStimPlanModelAtPosFeature.cpp

@@ -16,11 +16,11 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RicNewWellPathFractureModelAtPosFeature.h"
+#include "RicNewWellPathStimPlanModelAtPosFeature.h"
 
 #include "RiaApplication.h"
 
-#include "RicNewFractureModelFeature.h"
+#include "RicNewStimPlanModelFeature.h"
 
 #include "RimEclipseView.h"
 #include "RimTools.h"
@@ -31,12 +31,12 @@
 
 #include <QAction>
 
-CAF_CMD_SOURCE_INIT( RicNewWellPathFractureModelAtPosFeature, "RicNewWellPathFractureModelAtPosFeature" );
+CAF_CMD_SOURCE_INIT( RicNewWellPathStimPlanModelAtPosFeature, "RicNewWellPathStimPlanModelAtPosFeature" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewWellPathFractureModelAtPosFeature::onActionTriggered( bool isChecked )
+void RicNewWellPathStimPlanModelAtPosFeature::onActionTriggered( bool isChecked )
 {
     Riu3dSelectionManager* riuSelManager = Riu3dSelectionManager::instance();
     RiuSelectionItem*      selItem       = riuSelManager->selectedItem( Riu3dSelectionManager::RUI_TEMPORARY );
@@ -59,7 +59,7 @@ void RicNewWellPathFractureModelAtPosFeature::onActionTriggered( bool isChecked
         timeStep    = activeView->currentTimeStep();
     }
 
-    RicNewFractureModelFeature::addFractureModel( wellPath,
+    RicNewStimPlanModelFeature::addStimPlanModel( wellPath,
                                                   wellPathCollection,
                                                   eclipseCase,
                                                   timeStep,
@@ -69,16 +69,16 @@ void RicNewWellPathFractureModelAtPosFeature::onActionTriggered( bool isChecked
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicNewWellPathFractureModelAtPosFeature::setupActionLook( QAction* actionToSetup )
+void RicNewWellPathStimPlanModelAtPosFeature::setupActionLook( QAction* actionToSetup )
 {
     actionToSetup->setIcon( QIcon( ":/FractureSymbol16x16.png" ) );
-    actionToSetup->setText( "Create Fracture Model at this Depth" );
+    actionToSetup->setText( "Create StimPlan Model at this Depth" );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RicNewWellPathFractureModelAtPosFeature::isCommandEnabled()
+bool RicNewWellPathStimPlanModelAtPosFeature::isCommandEnabled()
 {
     return true;
 }

ApplicationCode/Commands/FractureCommands/RicNewWellPathStimPlanModelAtPosFeature.h

@@ -25,7 +25,7 @@
 //==================================================================================================
 ///
 //==================================================================================================
-class RicNewWellPathFractureModelAtPosFeature : public caf::CmdFeature
+class RicNewWellPathStimPlanModelAtPosFeature : public caf::CmdFeature
 {
     CAF_CMD_HEADER_INIT;
 

ApplicationCode/Commands/RicElasticPropertiesImportTools.cpp

@@ -30,9 +30,9 @@
 #include "RimElasticProperties.h"
 #include "RimFormationNames.h"
 #include "RimFormationNamesCollection.h"
-#include "RimFractureModelTemplate.h"
 #include "RimOilField.h"
 #include "RimProject.h"
+#include "RimStimPlanModelTemplate.h"
 
 #include <set>
 #include <vector>
@@ -41,7 +41,7 @@
 ///
 //--------------------------------------------------------------------------------------------------
 void RicElasticPropertiesImportTools::importElasticPropertiesFromFile( const QString&            filePath,
-                                                                       RimFractureModelTemplate* fractureModelTemplate,
+                                                                       RimStimPlanModelTemplate* stimPlanModelTemplate,
                                                                        const QString&            formationWildCard )
 {
     RifCsvUserDataFileParser csvParser( filePath );
@@ -85,7 +85,7 @@ void RicElasticPropertiesImportTools::importElasticPropertiesFromFile( const QSt
         }
     }
 
-    RimElasticProperties* rimElasticProperties = fractureModelTemplate->elasticProperties();
+    RimElasticProperties* rimElasticProperties = stimPlanModelTemplate->elasticProperties();
     if ( !rimElasticProperties ) rimElasticProperties = new RimElasticProperties;
     for ( FaciesKey key : faciesKeys )
     {
@@ -147,8 +147,8 @@ void RicElasticPropertiesImportTools::importElasticPropertiesFromFile( const QSt
     }
 
     rimElasticProperties->setFilePath( filePath );
-    fractureModelTemplate->setElasticProperties( rimElasticProperties );
+    stimPlanModelTemplate->setElasticProperties( rimElasticProperties );
-    fractureModelTemplate->updateConnectedEditors();
+    stimPlanModelTemplate->updateConnectedEditors();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/Commands/RicElasticPropertiesImportTools.h

@@ -21,7 +21,7 @@
 #include <QString>
 #include <vector>
 
-class RimFractureModelTemplate;
+class RimStimPlanModelTemplate;
 
 //--------------------------------------------------------------------------------------------------
 ///
@@ -30,7 +30,7 @@ class RicElasticPropertiesImportTools
 {
 public:
     static void importElasticPropertiesFromFile( const QString&            filePath,
-                                                 RimFractureModelTemplate* fractureModelTemplate,
+                                                 RimStimPlanModelTemplate* stimPlanModelTemplate,
                                                  const QString&            formationWildCard = "1*" );
 
 private:

ApplicationCode/Commands/RicExportStimPlanModelToFileFeature.cpp

@@ -16,27 +16,27 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RicExportFractureModelToFileFeature.h"
+#include "RicExportStimPlanModelToFileFeature.h"
 
 #include "RiaApplication.h"
 
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
 
 #include "RiuFileDialogTools.h"
 
-#include "RifFractureModelExporter.h"
+#include "RifStimPlanModelExporter.h"
 
 #include "cafSelectionManager.h"
 #include "cafUtils.h"
 
 #include <QAction>
 
-CAF_CMD_SOURCE_INIT( RicExportFractureModelToFileFeature, "RicExportFractureModelToFileFeature" );
+CAF_CMD_SOURCE_INIT( RicExportStimPlanModelToFileFeature, "RicExportStimPlanModelToFileFeature" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RicExportFractureModelToFileFeature::isCommandEnabled()
+bool RicExportStimPlanModelToFileFeature::isCommandEnabled()
 {
     return true;
 }
@@ -44,21 +44,21 @@ bool RicExportFractureModelToFileFeature::isCommandEnabled()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicExportFractureModelToFileFeature::onActionTriggered( bool isChecked )
+void RicExportStimPlanModelToFileFeature::onActionTriggered( bool isChecked )
 {
-    RimFractureModel* fractureModel = caf::SelectionManager::instance()->selectedItemOfType<RimFractureModel>();
+    RimStimPlanModel* stimPlanModel = caf::SelectionManager::instance()->selectedItemOfType<RimStimPlanModel>();
-    if ( !fractureModel ) return;
+    if ( !stimPlanModel ) return;
-    if ( !fractureModel->fractureModelTemplate() ) return;
+    if ( !stimPlanModel->stimPlanModelTemplate() ) return;
 
     RiaApplication* app        = RiaApplication::instance();
     QString         defaultDir = app->lastUsedDialogDirectory( "FRACTURE_MODEL_EXPORT" );
 
     QString directoryPath =
-        RiuFileDialogTools::getExistingDirectory( nullptr, "Select Directory for Fracture Model Export", defaultDir );
+        RiuFileDialogTools::getExistingDirectory( nullptr, "Select Directory for StimPlan Model Export", defaultDir );
 
     if ( directoryPath.isEmpty() ) return;
 
-    RifFractureModelExporter::writeToDirectory( fractureModel, fractureModel->useDetailedFluidLoss(), directoryPath );
+    RifStimPlanModelExporter::writeToDirectory( stimPlanModel, stimPlanModel->useDetailedFluidLoss(), directoryPath );
 
     // Remember the path to next time
     app->setLastUsedDialogDirectory( "FRACTURE_MODEL_EXPORT", directoryPath );
@@ -67,8 +67,8 @@ void RicExportFractureModelToFileFeature::onActionTriggered( bool isChecked )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicExportFractureModelToFileFeature::setupActionLook( QAction* actionToSetup )
+void RicExportStimPlanModelToFileFeature::setupActionLook( QAction* actionToSetup )
 {
-    actionToSetup->setText( "Export Fracture Model to File" );
+    actionToSetup->setText( "Export StimPlan Model to File" );
     actionToSetup->setIcon( QIcon( ":/Save.svg" ) );
 }

ApplicationCode/Commands/RicExportStimPlanModelToFileFeature.h

@@ -23,7 +23,7 @@
 //==================================================================================================
 ///
 //==================================================================================================
-class RicExportFractureModelToFileFeature : public caf::CmdFeature
+class RicExportStimPlanModelToFileFeature : public caf::CmdFeature
 {
     CAF_CMD_HEADER_INIT;
 

ApplicationCode/Commands/RicFaciesPropertiesImportTools.cpp

@@ -28,8 +28,8 @@
 #include "RimColorLegendCollection.h"
 #include "RimColorLegendItem.h"
 #include "RimFaciesProperties.h"
-#include "RimFractureModelTemplate.h"
 #include "RimProject.h"
+#include "RimStimPlanModelTemplate.h"
 
 #include "RifColorLegendData.h"
 #include "RifRoffReader.h"
@@ -40,7 +40,7 @@
 ///
 //--------------------------------------------------------------------------------------------------
 void RicFaciesPropertiesImportTools::importFaciesPropertiesFromFile( const QString&            filePath,
-                                                                     RimFractureModelTemplate* fractureModelTemplate,
+                                                                     RimStimPlanModelTemplate* stimPlanModelTemplate,
                                                                      bool                      createColorLegend )
 {
     if ( filePath.isEmpty() ) return;
@@ -56,7 +56,7 @@ void RicFaciesPropertiesImportTools::importFaciesPropertiesFromFile( const QStri
         return;
     }
 
-    RimFaciesProperties* faciesProperties = fractureModelTemplate->faciesProperties();
+    RimFaciesProperties* faciesProperties = stimPlanModelTemplate->faciesProperties();
     if ( !faciesProperties )
     {
         faciesProperties = new RimFaciesProperties;
@@ -101,8 +101,8 @@ void RicFaciesPropertiesImportTools::importFaciesPropertiesFromFile( const QStri
 
     faciesProperties->setFilePath( filePath );
 
-    fractureModelTemplate->setFaciesProperties( faciesProperties );
+    stimPlanModelTemplate->setFaciesProperties( faciesProperties );
-    fractureModelTemplate->updateConnectedEditors();
+    stimPlanModelTemplate->updateConnectedEditors();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/Commands/RicFaciesPropertiesImportTools.h

@@ -19,7 +19,7 @@
 #pragma once
 
 class RimColorLegend;
-class RimFractureModelTemplate;
+class RimStimPlanModelTemplate;
 
 namespace cvf
 {
@@ -35,7 +35,7 @@ class RicFaciesPropertiesImportTools
 {
 public:
     static void importFaciesPropertiesFromFile( const QString&            filePath,
-                                                RimFractureModelTemplate* fractureModelTemplate,
+                                                RimStimPlanModelTemplate* stimPlanModelTemplate,
                                                 bool                      createColorLegend = false );
 
 private:

ApplicationCode/Commands/RicImportElasticPropertiesFeature.cpp

@@ -22,7 +22,7 @@
 
 #include "RicElasticPropertiesImportTools.h"
 
-#include "RimFractureModelTemplate.h"
+#include "RimStimPlanModelTemplate.h"
 
 #include "Riu3DMainWindowTools.h"
 #include "RiuFileDialogTools.h"
@@ -47,9 +47,9 @@ bool RicImportElasticPropertiesFeature::isCommandEnabled()
 //--------------------------------------------------------------------------------------------------
 void RicImportElasticPropertiesFeature::onActionTriggered( bool isChecked )
 {
-    RimFractureModelTemplate* fractureModelTemplate =
+    RimStimPlanModelTemplate* stimPlanModelTemplate =
-        caf::SelectionManager::instance()->selectedItemAncestorOfType<RimFractureModelTemplate>();
+        caf::SelectionManager::instance()->selectedItemAncestorOfType<RimStimPlanModelTemplate>();
-    if ( !fractureModelTemplate ) return;
+    if ( !stimPlanModelTemplate ) return;
 
     // Open dialog box to select files
     RiaApplication* app        = RiaApplication::instance();
@@ -64,7 +64,7 @@ void RicImportElasticPropertiesFeature::onActionTriggered( bool isChecked )
     // Remember the path to next time
     app->setLastUsedDialogDirectory( "STIMPLAN_DIR", QFileInfo( filePath ).absolutePath() );
 
-    RicElasticPropertiesImportTools::importElasticPropertiesFromFile( filePath, fractureModelTemplate );
+    RicElasticPropertiesImportTools::importElasticPropertiesFromFile( filePath, stimPlanModelTemplate );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/Commands/RicImportFaciesFeature.cpp

@@ -25,7 +25,7 @@
 
 #include "RicFaciesPropertiesImportTools.h"
 
-#include "RimFractureModelTemplate.h"
+#include "RimStimPlanModelTemplate.h"
 
 #include "cafSelectionManager.h"
 
@@ -47,9 +47,9 @@ bool RicImportFaciesFeature::isCommandEnabled()
 //--------------------------------------------------------------------------------------------------
 void RicImportFaciesFeature::onActionTriggered( bool isChecked )
 {
-    RimFractureModelTemplate* fractureModelTemplate =
+    RimStimPlanModelTemplate* stimPlanModelTemplate =
-        caf::SelectionManager::instance()->selectedItemAncestorOfType<RimFractureModelTemplate>();
+        caf::SelectionManager::instance()->selectedItemAncestorOfType<RimStimPlanModelTemplate>();
-    if ( !fractureModelTemplate ) return;
+    if ( !stimPlanModelTemplate ) return;
 
     RiaApplication* app        = RiaApplication::instance();
     QString         defaultDir = app->lastUsedDialogDirectoryWithFallbackToProjectFolder( "STIMPLAN_DIR" );
@@ -67,7 +67,7 @@ void RicImportFaciesFeature::onActionTriggered( bool isChecked )
     app->setLastUsedDialogDirectory( "STIMPLAN_DIR", QFileInfo( fileName ).absolutePath() );
 
     bool createColorLegend = true;
-    RicFaciesPropertiesImportTools::importFaciesPropertiesFromFile( fileName, fractureModelTemplate, createColorLegend );
+    RicFaciesPropertiesImportTools::importFaciesPropertiesFromFile( fileName, stimPlanModelTemplate, createColorLegend );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/Commands/WellLogCommands/RicNewWellLogPlotFeatureImpl.cpp

@@ -21,10 +21,10 @@
 
 #include "RimCase.h"
 #include "RimEclipseCase.h"
-#include "RimFractureModelPlot.h"
-#include "RimFractureModelPlotCollection.h"
 #include "RimMainPlotCollection.h"
 #include "RimProject.h"
+#include "RimStimPlanModelPlot.h"
+#include "RimStimPlanModelPlotCollection.h"
 #include "RimWellBoreStabilityPlot.h"
 #include "RimWellLogCurveCommonDataSource.h"
 #include "RimWellLogPlot.h"

ApplicationCode/FileInterface/CMakeLists_files.cmake

@@ -54,11 +54,11 @@ ${CMAKE_CURRENT_LIST_DIR}/RifSurfaceImporter.h
 ${CMAKE_CURRENT_LIST_DIR}/RifRoffReader.h
 ${CMAKE_CURRENT_LIST_DIR}/RifColorLegendData.h
 ${CMAKE_CURRENT_LIST_DIR}/RifElasticPropertiesReader.h
-${CMAKE_CURRENT_LIST_DIR}/RifFractureModelExporter.h
+${CMAKE_CURRENT_LIST_DIR}/RifStimPlanModelExporter.h
-${CMAKE_CURRENT_LIST_DIR}/RifFractureModelGeologicalFrkExporter.h
+${CMAKE_CURRENT_LIST_DIR}/RifStimPlanModelGeologicalFrkExporter.h
-${CMAKE_CURRENT_LIST_DIR}/RifFractureModelDeviationFrkExporter.h
+${CMAKE_CURRENT_LIST_DIR}/RifStimPlanModelDeviationFrkExporter.h
-${CMAKE_CURRENT_LIST_DIR}/RifFractureModelPerfsFrkExporter.h
+${CMAKE_CURRENT_LIST_DIR}/RifStimPlanModelPerfsFrkExporter.h
-${CMAKE_CURRENT_LIST_DIR}/RifFractureModelAsymmetricFrkExporter.h
+${CMAKE_CURRENT_LIST_DIR}/RifStimPlanModelAsymmetricFrkExporter.h
 ${CMAKE_CURRENT_LIST_DIR}/RifSurfaceExporter.h
 
 
@@ -119,11 +119,11 @@ ${CMAKE_CURRENT_LIST_DIR}/RifSurfaceImporter.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RifRoffReader.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RifColorLegendData.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RifElasticPropertiesReader.cpp
-${CMAKE_CURRENT_LIST_DIR}/RifFractureModelExporter.cpp
+${CMAKE_CURRENT_LIST_DIR}/RifStimPlanModelExporter.cpp
-${CMAKE_CURRENT_LIST_DIR}/RifFractureModelGeologicalFrkExporter.cpp
+${CMAKE_CURRENT_LIST_DIR}/RifStimPlanModelGeologicalFrkExporter.cpp
-${CMAKE_CURRENT_LIST_DIR}/RifFractureModelDeviationFrkExporter.cpp
+${CMAKE_CURRENT_LIST_DIR}/RifStimPlanModelDeviationFrkExporter.cpp
-${CMAKE_CURRENT_LIST_DIR}/RifFractureModelPerfsFrkExporter.cpp
+${CMAKE_CURRENT_LIST_DIR}/RifStimPlanModelPerfsFrkExporter.cpp
-${CMAKE_CURRENT_LIST_DIR}/RifFractureModelAsymmetricFrkExporter.cpp
+${CMAKE_CURRENT_LIST_DIR}/RifStimPlanModelAsymmetricFrkExporter.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RifSurfaceExporter.cpp
 
 # HDF5 file reader is directly included in ResInsight main CmakeList.txt

ApplicationCode/FileInterface/RifStimPlanModelAsymmetricFrkExporter.cpp

@@ -16,9 +16,9 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RifFractureModelAsymmetricFrkExporter.h"
+#include "RifStimPlanModelAsymmetricFrkExporter.h"
 
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
 
 #include <QFile>
 #include <QTextStream>
@@ -26,7 +26,7 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifFractureModelAsymmetricFrkExporter::writeToFile( RimFractureModel* fractureModel, const QString& filepath )
+bool RifStimPlanModelAsymmetricFrkExporter::writeToFile( RimStimPlanModel* stimPlanModel, const QString& filepath )
 {
     QFile data( filepath );
     if ( !data.open( QFile::WriteOnly | QFile::Truncate ) )
@@ -37,11 +37,11 @@ bool RifFractureModelAsymmetricFrkExporter::writeToFile( RimFractureModel* fract
     QTextStream stream( &data );
     appendHeaderToStream( stream );
 
-    double bedDipDeg            = fractureModel->formationDip();
+    double bedDipDeg            = stimPlanModel->formationDip();
-    bool   hasBarrier           = fractureModel->hasBarrier();
+    bool   hasBarrier           = stimPlanModel->hasBarrier();
-    double distanceToBarrier    = fractureModel->distanceToBarrier();
+    double distanceToBarrier    = stimPlanModel->distanceToBarrier();
-    double barrierDip           = fractureModel->barrierDip();
+    double barrierDip           = stimPlanModel->barrierDip();
-    int    wellPenetrationLayer = fractureModel->wellPenetrationLayer();
+    int    wellPenetrationLayer = stimPlanModel->wellPenetrationLayer();
 
     appendBarrierDataToStream( stream,
                                bedDipDeg,
@@ -58,7 +58,7 @@ bool RifFractureModelAsymmetricFrkExporter::writeToFile( RimFractureModel* fract
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelAsymmetricFrkExporter::appendHeaderToStream( QTextStream& stream )
+void RifStimPlanModelAsymmetricFrkExporter::appendHeaderToStream( QTextStream& stream )
 {
     stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << endl << "<asymmetric>" << endl;
 }
@@ -66,7 +66,7 @@ void RifFractureModelAsymmetricFrkExporter::appendHeaderToStream( QTextStream& s
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelAsymmetricFrkExporter::appendBarrierDataToStream( QTextStream& stream,
+void RifStimPlanModelAsymmetricFrkExporter::appendBarrierDataToStream( QTextStream& stream,
                                                                        double       bedDipDeg,
                                                                        bool         hasBarrier,
                                                                        double       distanceToBarrier,
@@ -93,7 +93,7 @@ void RifFractureModelAsymmetricFrkExporter::appendBarrierDataToStream( QTextStre
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelAsymmetricFrkExporter::appendFooterToStream( QTextStream& stream )
+void RifStimPlanModelAsymmetricFrkExporter::appendFooterToStream( QTextStream& stream )
 {
     stream << "</asymmetric>" << endl;
 }

ApplicationCode/FileInterface/RifStimPlanModelAsymmetricFrkExporter.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-class RimFractureModel;
+class RimStimPlanModel;
 
 class QString;
 class QTextStream;
@@ -26,10 +26,10 @@ class QTextStream;
 //==================================================================================================
 //
 //==================================================================================================
-class RifFractureModelAsymmetricFrkExporter
+class RifStimPlanModelAsymmetricFrkExporter
 {
 public:
-    static bool writeToFile( RimFractureModel* fractureModel, const QString& filepath );
+    static bool writeToFile( RimStimPlanModel* stimPlanModel, const QString& filepath );
 
 private:
     static void appendHeaderToStream( QTextStream& stream );

ApplicationCode/FileInterface/RifStimPlanModelDeviationFrkExporter.cpp

@@ -16,9 +16,9 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RifFractureModelDeviationFrkExporter.h"
+#include "RifStimPlanModelDeviationFrkExporter.h"
 
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
 #include "RimWellPath.h"
 
 #include "RigWellPathGeometryExporter.h"
@@ -29,9 +29,9 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifFractureModelDeviationFrkExporter::writeToFile( RimFractureModel* fractureModel, const QString& filepath )
+bool RifStimPlanModelDeviationFrkExporter::writeToFile( RimStimPlanModel* stimPlanModel, const QString& filepath )
 {
-    RimWellPath* wellPath = fractureModel->wellPath();
+    RimWellPath* wellPath = stimPlanModel->wellPath();
     if ( !wellPath )
     {
         return false;
@@ -71,7 +71,7 @@ bool RifFractureModelDeviationFrkExporter::writeToFile( RimFractureModel* fractu
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelDeviationFrkExporter::appendHeaderToStream( QTextStream& stream )
+void RifStimPlanModelDeviationFrkExporter::appendHeaderToStream( QTextStream& stream )
 {
     stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << endl << "<deviation>" << endl;
 }
@@ -79,7 +79,7 @@ void RifFractureModelDeviationFrkExporter::appendHeaderToStream( QTextStream& st
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelDeviationFrkExporter::appendToStream( QTextStream&               stream,
+void RifStimPlanModelDeviationFrkExporter::appendToStream( QTextStream&               stream,
                                                            const QString&             label,
                                                            const std::vector<double>& values )
 {
@@ -106,7 +106,7 @@ void RifFractureModelDeviationFrkExporter::appendToStream( QTextStream&
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelDeviationFrkExporter::appendFooterToStream( QTextStream& stream )
+void RifStimPlanModelDeviationFrkExporter::appendFooterToStream( QTextStream& stream )
 {
     stream << "</deviation>" << endl;
 }
@@ -114,7 +114,7 @@ void RifFractureModelDeviationFrkExporter::appendFooterToStream( QTextStream& st
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelDeviationFrkExporter::convertFromMeterToFeet( std::vector<double>& data )
+void RifStimPlanModelDeviationFrkExporter::convertFromMeterToFeet( std::vector<double>& data )
 {
     for ( size_t i = 0; i < data.size(); i++ )
     {
@@ -125,7 +125,7 @@ void RifFractureModelDeviationFrkExporter::convertFromMeterToFeet( std::vector<d
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelDeviationFrkExporter::fixupDepthValuesForExport( const std::vector<double>& tvdValues,
+void RifStimPlanModelDeviationFrkExporter::fixupDepthValuesForExport( const std::vector<double>& tvdValues,
                                                                       const std::vector<double>& mdValues,
                                                                       std::vector<double>&       exportTvdValues,
                                                                       std::vector<double>&       exportMdValues )

ApplicationCode/FileInterface/RifStimPlanModelDeviationFrkExporter.h

@@ -20,17 +20,17 @@
 
 #include <vector>
 
-class RimFractureModel;
+class RimStimPlanModel;
 class QString;
 class QTextStream;
 
 //==================================================================================================
 //
 //==================================================================================================
-class RifFractureModelDeviationFrkExporter
+class RifStimPlanModelDeviationFrkExporter
 {
 public:
-    static bool writeToFile( RimFractureModel* fractureModel, const QString& filepath );
+    static bool writeToFile( RimStimPlanModel* stimPlanModel, const QString& filepath );
 
     static void fixupDepthValuesForExport( const std::vector<double>& tvdValues,
                                            const std::vector<double>& mdValues,

ApplicationCode/FileInterface/RifStimPlanModelExporter.cpp

@@ -16,26 +16,26 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RifFractureModelExporter.h"
+#include "RifStimPlanModelExporter.h"
 
-#include "RifFractureModelAsymmetricFrkExporter.h"
+#include "RifStimPlanModelAsymmetricFrkExporter.h"
-#include "RifFractureModelDeviationFrkExporter.h"
+#include "RifStimPlanModelDeviationFrkExporter.h"
-#include "RifFractureModelGeologicalFrkExporter.h"
+#include "RifStimPlanModelGeologicalFrkExporter.h"
-#include "RifFractureModelPerfsFrkExporter.h"
+#include "RifStimPlanModelPerfsFrkExporter.h"
 
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifFractureModelExporter::writeToDirectory( RimFractureModel* fractureModel,
+bool RifStimPlanModelExporter::writeToDirectory( RimStimPlanModel* stimPlanModel,
                                                  bool              useDetailedFluidLoss,
                                                  const QString&    directoryPath )
 {
-    return RifFractureModelGeologicalFrkExporter::writeToFile( fractureModel,
+    return RifStimPlanModelGeologicalFrkExporter::writeToFile( stimPlanModel,
                                                                useDetailedFluidLoss,
                                                                directoryPath + "/Geological.frk" ) &&
-           RifFractureModelDeviationFrkExporter::writeToFile( fractureModel, directoryPath + "/Deviation.frk" ) &&
+           RifStimPlanModelDeviationFrkExporter::writeToFile( stimPlanModel, directoryPath + "/Deviation.frk" ) &&
-           RifFractureModelPerfsFrkExporter::writeToFile( fractureModel, directoryPath + "/Perfs.frk" ) &&
+           RifStimPlanModelPerfsFrkExporter::writeToFile( stimPlanModel, directoryPath + "/Perfs.frk" ) &&
-           RifFractureModelAsymmetricFrkExporter::writeToFile( fractureModel, directoryPath + "/Asymmetric.frk" );
+           RifStimPlanModelAsymmetricFrkExporter::writeToFile( stimPlanModel, directoryPath + "/Asymmetric.frk" );
 }

ApplicationCode/FileInterface/RifStimPlanModelExporter.h

@@ -20,15 +20,15 @@
 
 #include <vector>
 
-class RimFractureModel;
+class RimStimPlanModel;
 class QString;
 class QTextStream;
 
 //==================================================================================================
 //
 //==================================================================================================
-class RifFractureModelExporter
+class RifStimPlanModelExporter
 {
 public:
-    static bool writeToDirectory( RimFractureModel* fractureModel, bool useDetailedFluidLoss, const QString& directoryPath );
+    static bool writeToDirectory( RimStimPlanModel* stimPlanModel, bool useDetailedFluidLoss, const QString& directoryPath );
 };

ApplicationCode/FileInterface/RifStimPlanModelGeologicalFrkExporter.cpp

@@ -16,10 +16,10 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RifFractureModelGeologicalFrkExporter.h"
+#include "RifStimPlanModelGeologicalFrkExporter.h"
 
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
-#include "RimFractureModelCalculator.h"
+#include "RimStimPlanModelCalculator.h"
 
 #include <QFile>
 #include <QTextStream>
@@ -27,7 +27,7 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifFractureModelGeologicalFrkExporter::writeToFile( RimFractureModel* fractureModel,
+bool RifStimPlanModelGeologicalFrkExporter::writeToFile( RimStimPlanModel* stimPlanModel,
                                                          bool              useDetailedLoss,
                                                          const QString&    filepath )
 {
@@ -91,24 +91,24 @@ bool RifFractureModelGeologicalFrkExporter::writeToFile( RimFractureModel* fract
     }
 
     std::map<QString, std::vector<double>> values;
-    values["dpthlyr"]        = fractureModel->calculator()->calculateTrueVerticalDepth();
+    values["dpthlyr"]        = stimPlanModel->calculator()->calculateTrueVerticalDepth();
-    values["strs"]           = fractureModel->calculator()->calculateStress();
+    values["strs"]           = stimPlanModel->calculator()->calculateStress();
-    values["strsg"]          = fractureModel->calculator()->calculateStressGradient();
+    values["strsg"]          = stimPlanModel->calculator()->calculateStressGradient();
-    values["elyr"]           = fractureModel->calculator()->calculateYoungsModulus();
+    values["elyr"]           = stimPlanModel->calculator()->calculateYoungsModulus();
-    values["poissonr"]       = fractureModel->calculator()->calculatePoissonsRatio();
+    values["poissonr"]       = stimPlanModel->calculator()->calculatePoissonsRatio();
-    values["tuflyr"]         = fractureModel->calculator()->calculateKIc();
+    values["tuflyr"]         = stimPlanModel->calculator()->calculateKIc();
-    values["clyrc"]          = fractureModel->calculator()->calculateFluidLossCoefficient();
+    values["clyrc"]          = stimPlanModel->calculator()->calculateFluidLossCoefficient();
-    values["clyrs"]          = fractureModel->calculator()->calculateSpurtLoss();
+    values["clyrs"]          = stimPlanModel->calculator()->calculateSpurtLoss();
-    values["pembed"]         = fractureModel->calculator()->calculateProppandEmbedment();
+    values["pembed"]         = stimPlanModel->calculator()->calculateProppandEmbedment();
-    values["zoneResPres"]    = fractureModel->calculator()->calculateReservoirPressure();
+    values["zoneResPres"]    = stimPlanModel->calculator()->calculateReservoirPressure();
-    values["zoneWaterSat"]   = fractureModel->calculator()->calculateImmobileFluidSaturation();
+    values["zoneWaterSat"]   = stimPlanModel->calculator()->calculateImmobileFluidSaturation();
-    values["zonePorosity"]   = fractureModel->calculator()->calculatePorosity();
+    values["zonePorosity"]   = stimPlanModel->calculator()->calculatePorosity();
-    values["zoneHorizPerm"]  = fractureModel->calculator()->calculateHorizontalPermeability();
+    values["zoneHorizPerm"]  = stimPlanModel->calculator()->calculateHorizontalPermeability();
-    values["zoneVertPerm"]   = fractureModel->calculator()->calculateVerticalPermeability();
+    values["zoneVertPerm"]   = stimPlanModel->calculator()->calculateVerticalPermeability();
-    values["zoneTemp"]       = fractureModel->calculator()->calculateTemperature();
+    values["zoneTemp"]       = stimPlanModel->calculator()->calculateTemperature();
-    values["zoneRelPerm"]    = fractureModel->calculator()->calculateRelativePermeabilityFactor();
+    values["zoneRelPerm"]    = stimPlanModel->calculator()->calculateRelativePermeabilityFactor();
-    values["zonePoroElas"]   = fractureModel->calculator()->calculatePoroElasticConstant();
+    values["zonePoroElas"]   = stimPlanModel->calculator()->calculatePoroElasticConstant();
-    values["zoneThermalExp"] = fractureModel->calculator()->calculateThermalExpansionCoefficient();
+    values["zoneThermalExp"] = stimPlanModel->calculator()->calculateThermalExpansionCoefficient();
 
     QFile data( filepath );
     if ( !data.open( QFile::WriteOnly | QFile::Truncate ) )
@@ -129,12 +129,12 @@ bool RifFractureModelGeologicalFrkExporter::writeToFile( RimFractureModel* fract
     return true;
 }
 
-void RifFractureModelGeologicalFrkExporter::appendHeaderToStream( QTextStream& stream )
+void RifStimPlanModelGeologicalFrkExporter::appendHeaderToStream( QTextStream& stream )
 {
     stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << endl << "<geologic>" << endl;
 }
 
-void RifFractureModelGeologicalFrkExporter::appendToStream( QTextStream&               stream,
+void RifStimPlanModelGeologicalFrkExporter::appendToStream( QTextStream&               stream,
                                                             const QString&             label,
                                                             const std::vector<double>& values )
 {
@@ -157,7 +157,7 @@ void RifFractureModelGeologicalFrkExporter::appendToStream( QTextStream&
     stream << "</data>" << endl << "</cNamedSet>" << endl;
 }
 
-void RifFractureModelGeologicalFrkExporter::appendFooterToStream( QTextStream& stream )
+void RifStimPlanModelGeologicalFrkExporter::appendFooterToStream( QTextStream& stream )
 {
     stream << "</geologic>" << endl;
 }

ApplicationCode/FileInterface/RifStimPlanModelGeologicalFrkExporter.h

@@ -20,17 +20,17 @@
 
 #include <vector>
 
-class RimFractureModel;
+class RimStimPlanModel;
 class QString;
 class QTextStream;
 
 //==================================================================================================
 //
 //==================================================================================================
-class RifFractureModelGeologicalFrkExporter
+class RifStimPlanModelGeologicalFrkExporter
 {
 public:
-    static bool writeToFile( RimFractureModel* plot, bool useDetailedFluidLoss, const QString& filepath );
+    static bool writeToFile( RimStimPlanModel* plot, bool useDetailedFluidLoss, const QString& filepath );
 
 private:
     static void appendHeaderToStream( QTextStream& stream );

ApplicationCode/FileInterface/RifStimPlanModelPerfsFrkExporter.cpp

@@ -16,11 +16,11 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RifFractureModelPerfsFrkExporter.h"
+#include "RifStimPlanModelPerfsFrkExporter.h"
 
 #include "RiaLogging.h"
 
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
 #include "RimWellPath.h"
 
 #include "RigWellPath.h"
@@ -34,9 +34,9 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifFractureModelPerfsFrkExporter::writeToFile( RimFractureModel* fractureModel, const QString& filepath )
+bool RifStimPlanModelPerfsFrkExporter::writeToFile( RimStimPlanModel* stimPlanModel, const QString& filepath )
 {
-    RimWellPath* wellPath = fractureModel->wellPath();
+    RimWellPath* wellPath = stimPlanModel->wellPath();
     if ( !wellPath )
     {
         return false;
@@ -52,15 +52,15 @@ bool RifFractureModelPerfsFrkExporter::writeToFile( RimFractureModel* fractureMo
     appendHeaderToStream( stream );
 
     bool isTransverse =
-        ( fractureModel->fractureOrientation() == RimFractureModel::FractureOrientation::TRANSVERSE_WELL_PATH ||
+        ( stimPlanModel->fractureOrientation() == RimStimPlanModel::FractureOrientation::TRANSVERSE_WELL_PATH ||
-          fractureModel->fractureOrientation() == RimFractureModel::FractureOrientation::AZIMUTH );
+          stimPlanModel->fractureOrientation() == RimStimPlanModel::FractureOrientation::AZIMUTH );
 
     appendFractureOrientationToStream( stream, isTransverse );
 
     // Unit: meter
-    double perforationLength = fractureModel->perforationLength();
+    double perforationLength = stimPlanModel->perforationLength();
 
-    double anchorPositionMD = computeMeasuredDepthForPosition( wellPath, fractureModel->anchorPosition() );
+    double anchorPositionMD = computeMeasuredDepthForPosition( wellPath, stimPlanModel->anchorPosition() );
     double topMD            = anchorPositionMD - ( perforationLength / 2.0 );
     double bottomMD         = anchorPositionMD + ( perforationLength / 2.0 );
 
@@ -77,7 +77,7 @@ bool RifFractureModelPerfsFrkExporter::writeToFile( RimFractureModel* fractureMo
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelPerfsFrkExporter::appendHeaderToStream( QTextStream& stream )
+void RifStimPlanModelPerfsFrkExporter::appendHeaderToStream( QTextStream& stream )
 {
     stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << endl << "<perfs>" << endl;
 }
@@ -85,7 +85,7 @@ void RifFractureModelPerfsFrkExporter::appendHeaderToStream( QTextStream& stream
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelPerfsFrkExporter::appendFractureOrientationToStream( QTextStream& stream, bool isTransverse )
+void RifStimPlanModelPerfsFrkExporter::appendFractureOrientationToStream( QTextStream& stream, bool isTransverse )
 {
     stream << "<transverse>" << endl << static_cast<int>( isTransverse ) << endl << "</transverse>" << endl;
 }
@@ -93,7 +93,7 @@ void RifFractureModelPerfsFrkExporter::appendFractureOrientationToStream( QTextS
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelPerfsFrkExporter::appendPerforationToStream( QTextStream& stream, int index, double topMD, double bottomMD )
+void RifStimPlanModelPerfsFrkExporter::appendPerforationToStream( QTextStream& stream, int index, double topMD, double bottomMD )
 {
     stream << "<perf frac=\"" << index << "\">" << endl
            << "<topMD>" << endl
@@ -108,7 +108,7 @@ void RifFractureModelPerfsFrkExporter::appendPerforationToStream( QTextStream& s
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifFractureModelPerfsFrkExporter::appendFooterToStream( QTextStream& stream )
+void RifStimPlanModelPerfsFrkExporter::appendFooterToStream( QTextStream& stream )
 {
     stream << "</perfs>" << endl;
 }
@@ -116,7 +116,7 @@ void RifFractureModelPerfsFrkExporter::appendFooterToStream( QTextStream& stream
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RifFractureModelPerfsFrkExporter::computeMeasuredDepthForPosition( const RimWellPath* wellPath,
+double RifStimPlanModelPerfsFrkExporter::computeMeasuredDepthForPosition( const RimWellPath* wellPath,
                                                                           const cvf::Vec3d&  position )
 {
     const RigWellPath* wellPathGeometry = wellPath->wellPathGeometry();

ApplicationCode/FileInterface/RifStimPlanModelPerfsFrkExporter.h

@@ -20,7 +20,7 @@
 
 #include "cvfVector3.h"
 
-class RimFractureModel;
+class RimStimPlanModel;
 class RimWellPath;
 
 class QString;
@@ -29,10 +29,10 @@ class QTextStream;
 //==================================================================================================
 //
 //==================================================================================================
-class RifFractureModelPerfsFrkExporter
+class RifStimPlanModelPerfsFrkExporter
 {
 public:
-    static bool writeToFile( RimFractureModel* fractureModel, const QString& filepath );
+    static bool writeToFile( RimStimPlanModel* stimPlanModel, const QString& filepath );
 
 private:
     static void   appendHeaderToStream( QTextStream& stream );

ApplicationCode/ProjectDataModel/Completions/RimCompletionTemplateCollection.cpp

@@ -18,8 +18,8 @@
 
 #include "RimCompletionTemplateCollection.h"
 
-#include "RimFractureModelTemplateCollection.h"
 #include "RimFractureTemplateCollection.h"
+#include "RimStimPlanModelTemplateCollection.h"
 #include "RimValveTemplateCollection.h"
 
 #include "cafPdmUiTreeOrdering.h"
@@ -39,8 +39,8 @@ RimCompletionTemplateCollection::RimCompletionTemplateCollection()
     m_fractureTemplates = new RimFractureTemplateCollection;
     m_fractureTemplates->addDefaultEllipseTemplate();
 
-    CAF_PDM_InitFieldNoDefault( &m_fractureModelTemplates, "FractureModelTemplates", "", "", "", "" );
+    CAF_PDM_InitFieldNoDefault( &m_stimPlanModelTemplates, "StimPlanModelTemplates", "", "", "", "" );
-    m_fractureModelTemplates = new RimFractureModelTemplateCollection;
+    m_stimPlanModelTemplates = new RimStimPlanModelTemplateCollection;
 
     CAF_PDM_InitFieldNoDefault( &m_valveTemplates, "ValveTemplates", "", "", "", "" );
     m_valveTemplates = new RimValveTemplateCollection;
@@ -106,17 +106,17 @@ void RimCompletionTemplateCollection::setFractureTemplateCollection( RimFracture
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelTemplateCollection* RimCompletionTemplateCollection::fractureModelTemplateCollection()
+RimStimPlanModelTemplateCollection* RimCompletionTemplateCollection::stimPlanModelTemplateCollection()
 {
-    return m_fractureModelTemplates;
+    return m_stimPlanModelTemplates;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-const RimFractureModelTemplateCollection* RimCompletionTemplateCollection::fractureModelTemplateCollection() const
+const RimStimPlanModelTemplateCollection* RimCompletionTemplateCollection::stimPlanModelTemplateCollection() const
 {
-    return m_fractureModelTemplates;
+    return m_stimPlanModelTemplates;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -126,7 +126,7 @@ void RimCompletionTemplateCollection::defineUiTreeOrdering( caf::PdmUiTreeOrderi
                                                             QString                 uiConfigName /*= ""*/ )
 {
     uiTreeOrdering.add( m_fractureTemplates );
-    uiTreeOrdering.add( m_fractureModelTemplates );
+    uiTreeOrdering.add( m_stimPlanModelTemplates );
     uiTreeOrdering.add( m_valveTemplates );
     uiTreeOrdering.skipRemainingChildren( true );
 }
@@ -137,5 +137,5 @@ void RimCompletionTemplateCollection::defineUiTreeOrdering( caf::PdmUiTreeOrderi
 void RimCompletionTemplateCollection::loadAndUpdateData()
 {
     m_fractureTemplates->loadAndUpdateData();
-    m_fractureModelTemplates->loadAndUpdateData();
+    m_stimPlanModelTemplates->loadAndUpdateData();
 }

ApplicationCode/ProjectDataModel/Completions/RimCompletionTemplateCollection.h

@@ -24,7 +24,7 @@
 class RimOilField;
 class RimValveTemplateCollection;
 class RimFractureTemplateCollection;
-class RimFractureModelTemplateCollection;
+class RimStimPlanModelTemplateCollection;
 
 class RimCompletionTemplateCollection : public caf::PdmObject
 {
@@ -36,8 +36,8 @@ public:
 
     RimFractureTemplateCollection*            fractureTemplateCollection();
     const RimFractureTemplateCollection*      fractureTemplateCollection() const;
-    RimFractureModelTemplateCollection*       fractureModelTemplateCollection();
+    RimStimPlanModelTemplateCollection*       stimPlanModelTemplateCollection();
-    const RimFractureModelTemplateCollection* fractureModelTemplateCollection() const;
+    const RimStimPlanModelTemplateCollection* stimPlanModelTemplateCollection() const;
     RimValveTemplateCollection*               valveTemplateCollection();
     const RimValveTemplateCollection*         valveTemplateCollection() const;
     void                                      setDefaultUnitSystemBasedOnLoadedCases();
@@ -50,7 +50,7 @@ private:
 
     caf::PdmChildField<RimFractureTemplateCollection*>      m_fractureTemplates;
     caf::PdmChildField<RimValveTemplateCollection*>         m_valveTemplates;
-    caf::PdmChildField<RimFractureModelTemplateCollection*> m_fractureModelTemplates;
+    caf::PdmChildField<RimStimPlanModelTemplateCollection*> m_stimPlanModelTemplates;
 
 protected:
     void defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "" ) override;

ApplicationCode/ProjectDataModel/Completions/RimWellPathCompletions.cpp

@@ -23,10 +23,10 @@
 #include "RimFishboneWellPathCollection.h"
 #include "RimFishbonesCollection.h"
 #include "RimFishbonesMultipleSubs.h"
-#include "RimFractureModel.h"
-#include "RimFractureModelCollection.h"
 #include "RimPerforationCollection.h"
 #include "RimPerforationInterval.h"
+#include "RimStimPlanModel.h"
+#include "RimStimPlanModelCollection.h"
 #include "RimWellPathComponentInterface.h"
 #include "RimWellPathFracture.h"
 #include "RimWellPathFractureCollection.h"
@@ -112,9 +112,9 @@ RimWellPathCompletions::RimWellPathCompletions()
     m_fractureCollection = new RimWellPathFractureCollection;
     m_fractureCollection.uiCapability()->setUiHidden( true );
 
-    CAF_PDM_InitFieldNoDefault( &m_fractureModelCollection, "FractureModels", "Fracture Models", "", "", "" );
+    CAF_PDM_InitFieldNoDefault( &m_stimPlanModelCollection, "StimPlanModels", "StimPlan Models", "", "", "" );
-    m_fractureModelCollection = new RimFractureModelCollection;
+    m_stimPlanModelCollection = new RimStimPlanModelCollection;
-    m_fractureModelCollection.uiCapability()->setUiHidden( true );
+    m_stimPlanModelCollection.uiCapability()->setUiHidden( true );
 
     CAF_PDM_InitField( &m_wellNameForExport, "WellNameForExport", QString(), "Well Name", "", "", "" );
     m_wellNameForExport.uiCapability()->setUiEditorTypeName( caf::PdmUiLineEditor::uiEditorTypeName() );
@@ -233,11 +233,11 @@ RimWellPathFractureCollection* RimWellPathCompletions::fractureCollection() cons
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelCollection* RimWellPathCompletions::fractureModelCollection() const
+RimStimPlanModelCollection* RimWellPathCompletions::stimPlanModelCollection() const
 {
-    CVF_ASSERT( m_fractureModelCollection );
+    CVF_ASSERT( m_stimPlanModelCollection );
 
-    return m_fractureModelCollection;
+    return m_stimPlanModelCollection;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -284,7 +284,7 @@ std::vector<const RimWellPathComponentInterface*> RimWellPathCompletions::allCom
 //--------------------------------------------------------------------------------------------------
 bool RimWellPathCompletions::hasCompletions() const
 {
-    if ( !fractureCollection()->allFractures().empty() || !fractureModelCollection()->allFractureModels().empty() )
+    if ( !fractureCollection()->allFractures().empty() || !stimPlanModelCollection()->allStimPlanModels().empty() )
     {
         return true;
     }
@@ -411,9 +411,9 @@ void RimWellPathCompletions::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTre
         uiTreeOrdering.add( &m_fractureCollection );
     }
 
-    if ( !fractureModelCollection()->allFractureModels().empty() )
+    if ( !stimPlanModelCollection()->allStimPlanModels().empty() )
     {
-        uiTreeOrdering.add( &m_fractureModelCollection );
+        uiTreeOrdering.add( &m_stimPlanModelCollection );
     }
 }
 

ApplicationCode/ProjectDataModel/Completions/RimWellPathCompletions.h

@@ -27,7 +27,7 @@ class RimPerforationCollection;
 class RimWellPathFractureCollection;
 class RimWellPathComponentInterface;
 class RimWellPathValve;
-class RimFractureModelCollection;
+class RimStimPlanModelCollection;
 
 //==================================================================================================
 ///
@@ -75,7 +75,7 @@ public:
     RimFishbonesCollection*        fishbonesCollection() const;
     RimPerforationCollection*      perforationCollection() const;
     RimWellPathFractureCollection* fractureCollection() const;
-    RimFractureModelCollection*    fractureModelCollection() const;
+    RimStimPlanModelCollection*    stimPlanModelCollection() const;
     std::vector<RimWellPathValve*> valves() const;
 
     std::vector<const RimWellPathComponentInterface*> allCompletions() const;
@@ -114,7 +114,7 @@ private:
     caf::PdmChildField<RimFishbonesCollection*>        m_fishbonesCollection;
     caf::PdmChildField<RimPerforationCollection*>      m_perforationCollection;
     caf::PdmChildField<RimWellPathFractureCollection*> m_fractureCollection;
-    caf::PdmChildField<RimFractureModelCollection*>    m_fractureModelCollection;
+    caf::PdmChildField<RimStimPlanModelCollection*>    m_stimPlanModelCollection;
 
     caf::PdmField<QString> m_wellNameForExport;
     caf::PdmField<QString> m_wellGroupName;

ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp

@@ -71,11 +71,6 @@
 #include "RimFlowPlotCollection.h"
 #include "RimFormationNames.h"
 #include "RimFormationNamesCollection.h"
-#include "RimFractureModel.h"
-#include "RimFractureModelCollection.h"
-#include "RimFractureModelPlot.h"
-#include "RimFractureModelTemplate.h"
-#include "RimFractureModelTemplateCollection.h"
 #include "RimFractureTemplate.h"
 #include "RimFractureTemplateCollection.h"
 #include "RimGeoMechCase.h"
@@ -112,6 +107,11 @@
 #include "RimSimWellInView.h"
 #include "RimSimWellInViewCollection.h"
 #include "RimStimPlanFractureTemplate.h"
+#include "RimStimPlanModel.h"
+#include "RimStimPlanModelCollection.h"
+#include "RimStimPlanModelPlot.h"
+#include "RimStimPlanModelTemplate.h"
+#include "RimStimPlanModelTemplateCollection.h"
 #include "RimSummaryCase.h"
 #include "RimSummaryCaseCollection.h"
 #include "RimSummaryCaseMainCollection.h"
@@ -404,7 +404,7 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
             menuBuilder << "RicNewPerforationIntervalFeature";
             menuBuilder << "RicNewFishbonesSubsFeature";
             menuBuilder << "RicNewWellPathFractureFeature";
-            menuBuilder << "RicNewFractureModelFeature";
+            menuBuilder << "RicNewStimPlanModelFeature";
             menuBuilder.subMenuEnd();
             menuBuilder << "RicCreateTemporaryLgrFeature";
             menuBuilder.addSeparator();
@@ -437,15 +437,15 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
         {
             menuBuilder << "RicDeleteWellPathAttributeFeature";
         }
-        else if ( dynamic_cast<RimFractureModel*>( firstUiItem ) )
+        else if ( dynamic_cast<RimStimPlanModel*>( firstUiItem ) )
         {
-            menuBuilder << "RicNewFractureModelFeature";
+            menuBuilder << "RicNewStimPlanModelFeature";
-            menuBuilder << "RicNewFractureModelPlotFeature";
+            menuBuilder << "RicNewStimPlanModelPlotFeature";
-            menuBuilder << "RicExportFractureModelToFileFeature";
+            menuBuilder << "RicExportStimPlanModelToFileFeature";
         }
-        else if ( dynamic_cast<RimFractureModelCollection*>( firstUiItem ) )
+        else if ( dynamic_cast<RimStimPlanModelCollection*>( firstUiItem ) )
         {
-            menuBuilder << "RicNewFractureModelFeature";
+            menuBuilder << "RicNewStimPlanModelFeature";
         }
         else if ( dynamic_cast<Rim3dWellLogCurveCollection*>( firstUiItem ) ||
                   dynamic_cast<Rim3dWellLogExtractionCurve*>( firstUiItem ) ||
@@ -874,14 +874,14 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
         {
             menuBuilder << "RicDeleteValveTemplateFeature";
         }
-        else if ( dynamic_cast<RimFractureModelTemplate*>( firstUiItem ) )
+        else if ( dynamic_cast<RimStimPlanModelTemplate*>( firstUiItem ) )
         {
             menuBuilder << "RicImportFaciesFeature";
             menuBuilder << "RicImportElasticPropertiesFeature";
         }
-        else if ( dynamic_cast<RimFractureModelTemplateCollection*>( firstUiItem ) )
+        else if ( dynamic_cast<RimStimPlanModelTemplateCollection*>( firstUiItem ) )
         {
-            menuBuilder << "RicNewFractureModelTemplateFeature";
+            menuBuilder << "RicNewStimPlanModelTemplateFeature";
         }
         else if ( dynamic_cast<RimFractureTemplateCollection*>( firstUiItem ) )
         {
@@ -1313,7 +1313,7 @@ int RimContextCommandBuilder::appendCreateCompletions( caf::CmdFeatureMenuBuilde
     candidates << "RicNewValveFeature";
     candidates << "RicNewFishbonesSubsFeature";
     candidates << "RicNewWellPathFractureFeature";
-    candidates << "RicNewFractureModelFeature";
+    candidates << "RicNewStimPlanModelFeature";
     candidates << "Separator";
     candidates << "RicCreateMultipleFracturesFeature";
     candidates << "RicNewWellPathAttributeFeature";

ApplicationCode/ProjectDataModel/RimMainPlotCollection.cpp

@@ -22,8 +22,6 @@
 #include "RimCorrelationPlotCollection.h"
 #include "RimFlowCharacteristicsPlot.h"
 #include "RimFlowPlotCollection.h"
-#include "RimFractureModelPlot.h"
-#include "RimFractureModelPlotCollection.h"
 #include "RimGridCrossPlot.h"
 #include "RimGridCrossPlotCollection.h"
 #include "RimMultiPlot.h"
@@ -32,6 +30,8 @@
 #include "RimProject.h"
 #include "RimRftPlotCollection.h"
 #include "RimSaturationPressurePlotCollection.h"
+#include "RimStimPlanModelPlot.h"
+#include "RimStimPlanModelPlotCollection.h"
 #include "RimSummaryAddress.h"
 #include "RimSummaryCrossPlotCollection.h"
 #include "RimSummaryPlotCollection.h"
@@ -95,8 +95,8 @@ RimMainPlotCollection::RimMainPlotCollection()
     CAF_PDM_InitFieldNoDefault( &m_multiPlotCollection, "RimMultiPlotCollection", "Multi Plots", "", "", "" );
     m_multiPlotCollection.uiCapability()->setUiHidden( true );
 
-    CAF_PDM_InitFieldNoDefault( &m_fractureModelPlotCollection, "FractureModelPlotCollection", "", "", "", "" );
+    CAF_PDM_InitFieldNoDefault( &m_stimPlanModelPlotCollection, "StimPlanModelPlotCollection", "", "", "", "" );
-    m_fractureModelPlotCollection.uiCapability()->setUiHidden( true );
+    m_stimPlanModelPlotCollection.uiCapability()->setUiHidden( true );
 
     m_wellLogPlotCollection            = new RimWellLogPlotCollection();
     m_rftPlotCollection                = new RimRftPlotCollection();
@@ -109,7 +109,7 @@ RimMainPlotCollection::RimMainPlotCollection()
     m_multiPlotCollection              = new RimMultiPlotCollection;
     m_analysisPlotCollection           = new RimAnalysisPlotCollection;
     m_correlationPlotCollection        = new RimCorrelationPlotCollection;
-    m_fractureModelPlotCollection      = new RimFractureModelPlotCollection;
+    m_stimPlanModelPlotCollection      = new RimStimPlanModelPlotCollection;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -227,9 +227,9 @@ RimCorrelationPlotCollection* RimMainPlotCollection::correlationPlotCollection()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelPlotCollection* RimMainPlotCollection::fractureModelPlotCollection()
+RimStimPlanModelPlotCollection* RimMainPlotCollection::stimPlanModelPlotCollection()
 {
-    return m_fractureModelPlotCollection();
+    return m_stimPlanModelPlotCollection();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -248,7 +248,7 @@ void RimMainPlotCollection::deleteAllContainedObjects()
     m_multiPlotCollection()->deleteAllChildObjects();
     m_analysisPlotCollection()->deleteAllPlots();
     m_correlationPlotCollection()->deleteAllPlots();
-    m_fractureModelPlotCollection()->deleteAllPlots();
+    m_stimPlanModelPlotCollection()->deleteAllPlots();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -309,11 +309,11 @@ void RimMainPlotCollection::updatePlotsWithFormations()
         }
     }
 
-    if ( m_fractureModelPlotCollection )
+    if ( m_stimPlanModelPlotCollection )
     {
-        for ( RimFractureModelPlot* fractureModelPlot : m_fractureModelPlotCollection->fractureModelPlots() )
+        for ( RimStimPlanModelPlot* stimPlanModelPlot : m_stimPlanModelPlotCollection->stimPlanModelPlots() )
         {
-            fractureModelPlot->loadDataAndUpdate();
+            stimPlanModelPlot->loadDataAndUpdate();
         }
     }
 }

ApplicationCode/ProjectDataModel/RimMainPlotCollection.h

@@ -40,7 +40,7 @@ class RifReaderEclipseSummary;
 class RimEclipseResultCase;
 class RimFlowPlotCollection;
 class RimSaturationPressurePlotCollection;
-class RimFractureModelPlotCollection;
+class RimStimPlanModelPlotCollection;
 
 //==================================================================================================
 ///
@@ -65,7 +65,7 @@ public:
     RimGridCrossPlotCollection*          gridCrossPlotCollection();
     RimSaturationPressurePlotCollection* saturationPressurePlotCollection();
     RimMultiPlotCollection*              multiPlotCollection();
-    RimFractureModelPlotCollection*      fractureModelPlotCollection();
+    RimStimPlanModelPlotCollection*      stimPlanModelPlotCollection();
 
     void deleteAllContainedObjects();
     void updateCurrentTimeStepInPlots();
@@ -92,7 +92,7 @@ private:
     caf::PdmChildField<RimGridCrossPlotCollection*>          m_gridCrossPlotCollection;
     caf::PdmChildField<RimSaturationPressurePlotCollection*> m_saturationPressurePlotCollection;
     caf::PdmChildField<RimMultiPlotCollection*>              m_multiPlotCollection;
-    caf::PdmChildField<RimFractureModelPlotCollection*>      m_fractureModelPlotCollection;
+    caf::PdmChildField<RimStimPlanModelPlotCollection*>      m_stimPlanModelPlotCollection;
 
     caf::PdmField<bool> m_show;
 };

ApplicationCode/ProjectDataModel/RimProject.cpp

@@ -49,7 +49,6 @@
 #include "RimEclipseCaseCollection.h"
 #include "RimFlowPlotCollection.h"
 #include "RimFormationNamesCollection.h"
-#include "RimFractureModelPlotCollection.h"
 #include "RimFractureTemplate.h"
 #include "RimFractureTemplateCollection.h"
 #include "RimGeoMechCase.h"
@@ -70,6 +69,7 @@
 #include "RimRftPlotCollection.h"
 #include "RimSaturationPressurePlotCollection.h"
 #include "RimScriptCollection.h"
+#include "RimStimPlanModelPlotCollection.h"
 #include "RimSummaryCalculation.h"
 #include "RimSummaryCalculationCollection.h"
 #include "RimSummaryCaseCollection.h"
@@ -1449,9 +1449,9 @@ void RimProject::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, Q
                 itemCollection->add( mainPlotCollection->multiPlotCollection() );
             }
 
-            if ( mainPlotCollection->fractureModelPlotCollection() )
+            if ( mainPlotCollection->stimPlanModelPlotCollection() )
             {
-                itemCollection->add( mainPlotCollection->fractureModelPlotCollection() );
+                itemCollection->add( mainPlotCollection->stimPlanModelPlotCollection() );
             }
         }
 

ApplicationCode/ProjectDataModel/RimReloadCaseTools.cpp

@@ -100,11 +100,11 @@ void RimReloadCaseTools::clearAllGridData( RigEclipseCaseData* eclipseCaseData )
         matrixModelResults->clearAllResults();
     }
 
-    RigCaseCellResultsData* fractureModelResults =
+    RigCaseCellResultsData* stimPlanModelResults =
         eclipseCaseData->results( RiaDefines::PorosityModelType::FRACTURE_MODEL );
-    if ( fractureModelResults )
+    if ( stimPlanModelResults )
     {
-        fractureModelResults->clearAllResults();
+        stimPlanModelResults->clearAllResults();
     }
 }
 

ApplicationCode/ProjectDataModel/RimWellPath.cpp

@@ -35,9 +35,9 @@
 #include "Rim3dWellLogCurve.h"
 #include "Rim3dWellLogCurveCollection.h"
 #include "RimFishbonesMultipleSubs.h"
-#include "RimFractureModelCollection.h"
 #include "RimMainPlotCollection.h"
 #include "RimProject.h"
+#include "RimStimPlanModelCollection.h"
 #include "RimTools.h"
 #include "RimWellLogFile.h"
 #include "RimWellLogFileChannel.h"
@@ -305,21 +305,21 @@ const RimWellPathFractureCollection* RimWellPath::fractureCollection() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelCollection* RimWellPath::fractureModelCollection()
+RimStimPlanModelCollection* RimWellPath::stimPlanModelCollection()
 {
     CVF_ASSERT( m_completions );
 
-    return m_completions->fractureModelCollection();
+    return m_completions->stimPlanModelCollection();
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-const RimFractureModelCollection* RimWellPath::fractureModelCollection() const
+const RimStimPlanModelCollection* RimWellPath::stimPlanModelCollection() const
 {
     CVF_ASSERT( m_completions );
 
-    return m_completions->fractureModelCollection();
+    return m_completions->stimPlanModelCollection();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationCode/ProjectDataModel/RimWellPath.h

@@ -49,7 +49,7 @@ class RimProject;
 class RimWellLogFile;
 class RimFractureTemplateCollection;
 class RimFishboneWellPathCollection;
-class RimFractureModelCollection;
+class RimStimPlanModelCollection;
 class RimFishbonesCollection;
 class RimPerforationCollection;
 class RimWellPathAttributeCollection;
@@ -122,8 +122,8 @@ public:
     const RimPerforationCollection*       perforationIntervalCollection() const;
     RimWellPathFractureCollection*        fractureCollection();
     const RimWellPathFractureCollection*  fractureCollection() const;
-    RimFractureModelCollection*           fractureModelCollection();
+    RimStimPlanModelCollection*           stimPlanModelCollection();
-    const RimFractureModelCollection*     fractureModelCollection() const;
+    const RimStimPlanModelCollection*     stimPlanModelCollection() const;
     RimWellPathAttributeCollection*       attributeCollection();
     const RimWellPathAttributeCollection* attributeCollection() const;
 

ApplicationCode/ProjectDataModel/RimWellPathCollection.cpp

@@ -35,11 +35,11 @@
 #include "RimEclipseCase.h"
 #include "RimEclipseCaseCollection.h"
 #include "RimEclipseView.h"
-#include "RimFractureModel.h"
-#include "RimFractureModelCollection.h"
 #include "RimOilField.h"
 #include "RimPerforationCollection.h"
 #include "RimProject.h"
+#include "RimStimPlanModel.h"
+#include "RimStimPlanModelCollection.h"
 #include "RimWellLogFile.h"
 #include "RimWellMeasurementCollection.h"
 #include "RimWellPath.h"
@@ -254,12 +254,12 @@ void RimWellPathCollection::loadDataAndUpdate()
                 }
             }
 
-            RimFractureModelCollection* fractureModelCollection = wellPath->fractureModelCollection();
+            RimStimPlanModelCollection* stimPlanModelCollection = wellPath->stimPlanModelCollection();
-            if ( fractureModelCollection )
+            if ( stimPlanModelCollection )
             {
-                for ( RimFractureModel* fractureModel : fractureModelCollection->allFractureModels() )
+                for ( RimStimPlanModel* stimPlanModel : stimPlanModelCollection->allStimPlanModels() )
                 {
-                    fractureModel->loadDataAndUpdate();
+                    stimPlanModel->loadDataAndUpdate();
                 }
             }
         }

ApplicationCode/ProjectDataModel/StimPlanModel/CMakeLists_files.cmake

@@ -1,19 +1,19 @@
 
 set (SOURCE_GROUP_HEADER_FILES
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelCollection.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelCollection.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelTemplate.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelTemplate.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModel.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModel.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelTemplateCollection.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelTemplateCollection.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelCalculator.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelCalculator.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelCurve.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelCurve.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelElasticPropertyCalculator.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelElasticPropertyCalculator.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelLayerCalculator.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelLayerCalculator.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelPlotCollection.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelPlotCollection.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelPlot.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelPlot.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelPropertyCalculator.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelPropertyCalculator.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelPropertyCurve.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelPropertyCurve.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelStressCalculator.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelStressCalculator.h
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelWellLogCalculator.h
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelWellLogCalculator.h
 ${CMAKE_CURRENT_LIST_DIR}/RimElasticProperties.h
 ${CMAKE_CURRENT_LIST_DIR}/RimElasticPropertyScaling.h
 ${CMAKE_CURRENT_LIST_DIR}/RimElasticPropertyScalingCollection.h
@@ -22,18 +22,18 @@ ${CMAKE_CURRENT_LIST_DIR}/RimNonNetLayers.h
 )
 
 set (SOURCE_GROUP_SOURCE_FILES
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelCollection.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelCollection.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelTemplate.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelTemplate.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModel.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModel.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelTemplateCollection.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelTemplateCollection.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelCalculator.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelCalculator.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelCurve.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelCurve.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelElasticPropertyCalculator.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelElasticPropertyCalculator.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelLayerCalculator.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelLayerCalculator.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelPlotCollection.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelPlotCollection.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelPlot.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelPlot.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelStressCalculator.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelStressCalculator.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimFractureModelWellLogCalculator.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimStimPlanModelWellLogCalculator.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimElasticProperties.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimElasticPropertyScaling.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimElasticPropertyScalingCollection.cpp

ApplicationCode/ProjectDataModel/StimPlanModel/RimElasticProperties.cpp

@@ -19,7 +19,7 @@
 #include "RimElasticProperties.h"
 
 #include "RimElasticPropertyScalingCollection.h"
-#include "RimFractureModelTemplate.h"
+#include "RimStimPlanModelTemplate.h"
 
 #include "RicElasticPropertiesImportTools.h"
 
@@ -228,9 +228,9 @@ void RimElasticProperties::loadDataAndUpdate()
 {
     if ( !m_filePath().path().isEmpty() )
     {
-        RimFractureModelTemplate* fractureModelTemplate;
+        RimStimPlanModelTemplate* stimPlanModelTemplate;
-        firstAncestorOrThisOfType( fractureModelTemplate );
+        firstAncestorOrThisOfType( stimPlanModelTemplate );
-        RicElasticPropertiesImportTools::importElasticPropertiesFromFile( m_filePath().path(), fractureModelTemplate );
+        RicElasticPropertiesImportTools::importElasticPropertiesFromFile( m_filePath().path(), stimPlanModelTemplate );
     }
 }
 

ApplicationCode/ProjectDataModel/StimPlanModel/RimElasticPropertyScaling.cpp

@@ -24,8 +24,8 @@
 #include "RimEclipseCase.h"
 #include "RimElasticProperties.h"
 #include "RimFaciesProperties.h"
-#include "RimFractureModelTemplate.h"
 #include "RimProject.h"
+#include "RimStimPlanModelTemplate.h"
 
 #include "cafPdmFieldScriptingCapability.h"
 #include "cafPdmObjectScriptingCapability.h"
@@ -154,11 +154,11 @@ void RimElasticPropertyScaling::updateAutoName()
 //--------------------------------------------------------------------------------------------------
 RimColorLegend* RimElasticPropertyScaling::getFaciesColorLegend()
 {
-    RimFractureModelTemplate* fractureModelTemplate;
+    RimStimPlanModelTemplate* stimPlanModelTemplate;
-    firstAncestorOrThisOfType( fractureModelTemplate );
+    firstAncestorOrThisOfType( stimPlanModelTemplate );
-    if ( !fractureModelTemplate ) return nullptr;
+    if ( !stimPlanModelTemplate ) return nullptr;
 
-    RimFaciesProperties* faciesProperties = fractureModelTemplate->faciesProperties();
+    RimFaciesProperties* faciesProperties = stimPlanModelTemplate->faciesProperties();
     if ( !faciesProperties ) return nullptr;
 
     return faciesProperties->colorLegend();

ApplicationCode/ProjectDataModel/StimPlanModel/RimElasticPropertyScaling.h

@@ -21,7 +21,7 @@
 #include "cafPdmField.h"
 #include "cafPdmObject.h"
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "RimCheckableNamedObject.h"
 

ApplicationCode/ProjectDataModel/StimPlanModel/RimElasticPropertyScalingCollection.h

@@ -22,7 +22,7 @@
 #include "cafPdmField.h"
 #include "cafPdmObject.h"
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 class RimElasticPropertyScaling;
 

ApplicationCode/ProjectDataModel/StimPlanModel/RimFaciesProperties.cpp

@@ -20,9 +20,9 @@
 
 #include "RimColorLegend.h"
 #include "RimEclipseResultDefinition.h"
-#include "RimFractureModelTemplate.h"
 #include "RimProject.h"
 #include "RimRegularLegendConfig.h"
+#include "RimStimPlanModelTemplate.h"
 #include "RimTools.h"
 
 #include "RicFaciesPropertiesImportTools.h"
@@ -193,9 +193,9 @@ void RimFaciesProperties::loadDataAndUpdate()
 {
     if ( !m_filePath().path().isEmpty() )
     {
-        RimFractureModelTemplate* fractureModelTemplate;
+        RimStimPlanModelTemplate* stimPlanModelTemplate;
-        firstAncestorOrThisOfType( fractureModelTemplate );
+        firstAncestorOrThisOfType( stimPlanModelTemplate );
-        RicFaciesPropertiesImportTools::importFaciesPropertiesFromFile( m_filePath().path(), fractureModelTemplate );
+        RicFaciesPropertiesImportTools::importFaciesPropertiesFromFile( m_filePath().path(), stimPlanModelTemplate );
     }
 }
 

ApplicationCode/ProjectDataModel/StimPlanModel/RimNonNetLayers.cpp

@@ -23,8 +23,8 @@
 #include "RimEclipseCase.h"
 #include "RimEclipseResultDefinition.h"
 #include "RimFaciesProperties.h"
-#include "RimFractureModelTemplate.h"
 #include "RimProject.h"
+#include "RimStimPlanModelTemplate.h"
 
 #include "cafPdmFieldScriptingCapability.h"
 #include "cafPdmObjectScriptingCapability.h"
@@ -159,11 +159,11 @@ const QString& RimNonNetLayers::facies() const
 //--------------------------------------------------------------------------------------------------
 RimColorLegend* RimNonNetLayers::getFaciesColorLegend()
 {
-    RimFractureModelTemplate* fractureModelTemplate;
+    RimStimPlanModelTemplate* stimPlanModelTemplate;
-    firstAncestorOrThisOfType( fractureModelTemplate );
+    firstAncestorOrThisOfType( stimPlanModelTemplate );
-    if ( !fractureModelTemplate ) return nullptr;
+    if ( !stimPlanModelTemplate ) return nullptr;
 
-    RimFaciesProperties* faciesProperties = fractureModelTemplate->faciesProperties();
+    RimFaciesProperties* faciesProperties = stimPlanModelTemplate->faciesProperties();
     if ( !faciesProperties ) return nullptr;
 
     return faciesProperties->colorLegend();

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModel.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "RimCheckableNamedObject.h"
 #include "RimWellPathComponentInterface.h"
@@ -38,16 +38,16 @@ class RigEclipseCaseData;
 class RimAnnotationCollectionBase;
 class RimUserDefinedPolylinesAnnotation;
 class RimFaciesProperties;
-class RimFractureModelTemplate;
+class RimStimPlanModelTemplate;
 class RimTextAnnotation;
-class RimFractureModelCalculator;
+class RimStimPlanModelCalculator;
 class RimColorLegend;
 
 //==================================================================================================
 ///
 ///
 //==================================================================================================
-class RimFractureModel : public RimCheckableNamedObject, public RimWellPathComponentInterface
+class RimStimPlanModel : public RimCheckableNamedObject, public RimWellPathComponentInterface
 {
     CAF_PDM_HEADER_INIT;
 
@@ -78,8 +78,8 @@ public:
         GRADIENT
     };
 
-    RimFractureModel( void );
+    RimStimPlanModel( void );
-    ~RimFractureModel( void ) override;
+    ~RimStimPlanModel( void ) override;
 
     void setMD( double md );
 
@@ -160,15 +160,15 @@ public:
     double                    getOverburdenGradient( RiaDefines::CurveProperty curveProperty ) const;
     double                    getUnderburdenGradient( RiaDefines::CurveProperty curveProperty ) const;
 
-    void                      setFractureModelTemplate( RimFractureModelTemplate* fractureModelTemplate );
+    void                      setStimPlanModelTemplate( RimStimPlanModelTemplate* stimPlanModelTemplate );
-    RimFractureModelTemplate* fractureModelTemplate() const;
+    RimStimPlanModelTemplate* stimPlanModelTemplate() const;
 
     void updateReferringPlots();
 
-    std::shared_ptr<RimFractureModelCalculator> calculator() const;
+    std::shared_ptr<RimStimPlanModelCalculator> calculator() const;
 
-    RimFractureModel::MissingValueStrategy missingValueStrategy( RiaDefines::CurveProperty curveProperty ) const;
+    RimStimPlanModel::MissingValueStrategy missingValueStrategy( RiaDefines::CurveProperty curveProperty ) const;
-    RimFractureModel::BurdenStrategy       burdenStrategy( RiaDefines::CurveProperty curveProperty ) const;
+    RimStimPlanModel::BurdenStrategy       burdenStrategy( RiaDefines::CurveProperty curveProperty ) const;
     RiaDefines::ResultCatType              eclipseResultCategory( RiaDefines::CurveProperty curveProperty ) const;
     QString                                eclipseResultVariable( RiaDefines::CurveProperty curveProperty ) const;
 
@@ -213,7 +213,7 @@ private:
                                                    const cvf::Vec3d&   endPosition );
 
     void updateViewsAndPlots();
-    void fractureModelTemplateChanged( const caf::SignalEmitter* emitter );
+    void stimPlanModelTemplateChanged( const caf::SignalEmitter* emitter );
 
     void hideOtherFaults( const QString& targetFaultName );
     void showAllFaults();
@@ -235,8 +235,8 @@ protected:
     caf::PdmField<double>                       m_thermalExpansionCoeffientDefault;
     caf::PdmField<bool>                         m_useDetailedFluidLoss;
 
-    caf::PdmPtrField<RimFractureModelTemplate*> m_fractureModelTemplate;
+    caf::PdmPtrField<RimStimPlanModelTemplate*> m_stimPlanModelTemplate;
-    caf::PdmField<bool>                         m_editFractureModelTemplate;
+    caf::PdmField<bool>                         m_editStimPlanModelTemplate;
 
     caf::PdmField<caf::AppEnum<FractureOrientation>> m_fractureOrientation;
     caf::PdmField<double>                            m_azimuthAngle;
@@ -254,5 +254,5 @@ protected:
     caf::PdmField<bool>                                  m_showOnlyBarrierFault;
     caf::PdmField<bool>                                  m_showAllFaults;
 
-    std::shared_ptr<RimFractureModelCalculator> m_calculator;
+    std::shared_ptr<RimStimPlanModelCalculator> m_calculator;
 };

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelCalculator.cpp

@@ -15,58 +15,58 @@
 //  for more details.
 //
 /////////////////////////////////////////////////////////////////////////////////
-#include "RimFractureModelCalculator.h"
+#include "RimStimPlanModelCalculator.h"
 
 #include "RiaDefines.h"
-#include "RiaFractureModelDefines.h"
 #include "RiaLogging.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "RigEclipseCaseData.h"
 
 #include "RimEclipseResultDefinition.h"
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
-#include "RimFractureModelCalculator.h"
+#include "RimStimPlanModelCalculator.h"
-#include "RimFractureModelElasticPropertyCalculator.h"
+#include "RimStimPlanModelElasticPropertyCalculator.h"
-#include "RimFractureModelLayerCalculator.h"
+#include "RimStimPlanModelLayerCalculator.h"
-#include "RimFractureModelPropertyCalculator.h"
+#include "RimStimPlanModelPropertyCalculator.h"
-#include "RimFractureModelStressCalculator.h"
+#include "RimStimPlanModelStressCalculator.h"
-#include "RimFractureModelWellLogCalculator.h"
+#include "RimStimPlanModelWellLogCalculator.h"
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelCalculator::RimFractureModelCalculator()
+RimStimPlanModelCalculator::RimStimPlanModelCalculator()
 {
     m_resultCalculators.push_back(
-        std::unique_ptr<RimFractureModelPropertyCalculator>( new RimFractureModelWellLogCalculator( this ) ) );
+        std::unique_ptr<RimStimPlanModelPropertyCalculator>( new RimStimPlanModelWellLogCalculator( this ) ) );
     m_resultCalculators.push_back(
-        std::unique_ptr<RimFractureModelPropertyCalculator>( new RimFractureModelElasticPropertyCalculator( this ) ) );
+        std::unique_ptr<RimStimPlanModelPropertyCalculator>( new RimStimPlanModelElasticPropertyCalculator( this ) ) );
     m_resultCalculators.push_back(
-        std::unique_ptr<RimFractureModelPropertyCalculator>( new RimFractureModelLayerCalculator( this ) ) );
+        std::unique_ptr<RimStimPlanModelPropertyCalculator>( new RimStimPlanModelLayerCalculator( this ) ) );
     m_resultCalculators.push_back(
-        std::unique_ptr<RimFractureModelPropertyCalculator>( new RimFractureModelStressCalculator( this ) ) );
+        std::unique_ptr<RimStimPlanModelPropertyCalculator>( new RimStimPlanModelStressCalculator( this ) ) );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCalculator::setFractureModel( RimFractureModel* fractureModel )
+void RimStimPlanModelCalculator::setStimPlanModel( RimStimPlanModel* stimPlanModel )
 {
-    m_fractureModel = fractureModel;
+    m_stimPlanModel = stimPlanModel;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModel* RimFractureModelCalculator::fractureModel()
+RimStimPlanModel* RimStimPlanModelCalculator::stimPlanModel()
 {
-    return m_fractureModel;
+    return m_stimPlanModel;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimFractureModelCalculator::extractCurveData( RiaDefines::CurveProperty curveProperty,
+bool RimStimPlanModelCalculator::extractCurveData( RiaDefines::CurveProperty curveProperty,
                                                    int                       timeStep,
                                                    std::vector<double>&      values,
                                                    std::vector<double>&      measuredDepthValues,
@@ -78,7 +78,7 @@ bool RimFractureModelCalculator::extractCurveData( RiaDefines::CurveProperty cur
         if ( calculator->isMatching( curveProperty ) )
         {
             return calculator
-                ->calculate( curveProperty, m_fractureModel, timeStep, values, measuredDepthValues, tvDepthValues, rkbDiff );
+                ->calculate( curveProperty, m_stimPlanModel, timeStep, values, measuredDepthValues, tvDepthValues, rkbDiff );
         }
     }
 
@@ -88,7 +88,7 @@ bool RimFractureModelCalculator::extractCurveData( RiaDefines::CurveProperty cur
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::extractValues( RiaDefines::CurveProperty curveProperty, int timeStep ) const
+std::vector<double> RimStimPlanModelCalculator::extractValues( RiaDefines::CurveProperty curveProperty, int timeStep ) const
 {
     std::vector<double> values;
     std::vector<double> measuredDepthValues;
@@ -103,7 +103,7 @@ std::vector<double> RimFractureModelCalculator::extractValues( RiaDefines::Curve
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCalculator::calculateLayers( std::vector<std::pair<double, double>>& layerBoundaryDepths,
+void RimStimPlanModelCalculator::calculateLayers( std::vector<std::pair<double, double>>& layerBoundaryDepths,
                                                   std::vector<std::pair<size_t, size_t>>& layerBoundaryIndexes ) const
 {
     std::vector<double> layerValues;
@@ -112,7 +112,7 @@ void RimFractureModelCalculator::calculateLayers( std::vector<std::pair<double,
     double              rkbDiff;
 
     extractCurveData( RiaDefines::CurveProperty::LAYERS,
-                      m_fractureModel->timeStep(),
+                      m_stimPlanModel->timeStep(),
                       layerValues,
                       measuredDepthValues,
                       depths,
@@ -135,7 +135,7 @@ void RimFractureModelCalculator::calculateLayers( std::vector<std::pair<double,
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelCalculator::findValueAtTopOfLayer( const std::vector<double>&                    values,
+double RimStimPlanModelCalculator::findValueAtTopOfLayer( const std::vector<double>&                    values,
                                                           const std::vector<std::pair<size_t, size_t>>& layerBoundaryIndexes,
                                                           size_t                                        layerNo )
 {
@@ -146,7 +146,7 @@ double RimFractureModelCalculator::findValueAtTopOfLayer( const std::vector<doub
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelCalculator::findValueAtBottomOfLayer( const std::vector<double>&                    values,
+double RimStimPlanModelCalculator::findValueAtBottomOfLayer( const std::vector<double>&                    values,
                                                              const std::vector<std::pair<size_t, size_t>>& layerBoundaryIndexes,
                                                              size_t                                        layerNo )
 {
@@ -157,7 +157,7 @@ double RimFractureModelCalculator::findValueAtBottomOfLayer( const std::vector<d
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCalculator::computeAverageByLayer( const std::vector<std::pair<size_t, size_t>>& layerBoundaryIndexes,
+void RimStimPlanModelCalculator::computeAverageByLayer( const std::vector<std::pair<size_t, size_t>>& layerBoundaryIndexes,
                                                         const std::vector<double>&                    inputVector,
                                                         std::vector<double>&                          result )
 {
@@ -177,7 +177,7 @@ void RimFractureModelCalculator::computeAverageByLayer( const std::vector<std::p
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCalculator::extractTopOfLayerValues( const std::vector<std::pair<size_t, size_t>>& layerBoundaryIndexes,
+void RimStimPlanModelCalculator::extractTopOfLayerValues( const std::vector<std::pair<size_t, size_t>>& layerBoundaryIndexes,
                                                           const std::vector<double>&                    inputVector,
                                                           std::vector<double>&                          result )
 {
@@ -190,7 +190,7 @@ void RimFractureModelCalculator::extractTopOfLayerValues( const std::vector<std:
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateTrueVerticalDepth() const
+std::vector<double> RimStimPlanModelCalculator::calculateTrueVerticalDepth() const
 {
     std::vector<std::pair<double, double>> layerBoundaryDepths;
     std::vector<std::pair<size_t, size_t>> layerBoundaryIndexes;
@@ -211,13 +211,13 @@ std::vector<double> RimFractureModelCalculator::calculateTrueVerticalDepth() con
 ///
 //--------------------------------------------------------------------------------------------------
 std::vector<double>
-    RimFractureModelCalculator::findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty curveProperty ) const
+    RimStimPlanModelCalculator::findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty curveProperty ) const
 {
     std::vector<std::pair<double, double>> layerBoundaryDepths;
     std::vector<std::pair<size_t, size_t>> layerBoundaryIndexes;
     calculateLayers( layerBoundaryDepths, layerBoundaryIndexes );
 
-    std::vector<double> values = extractValues( curveProperty, m_fractureModel->timeStep() );
+    std::vector<double> values = extractValues( curveProperty, m_stimPlanModel->timeStep() );
     std::vector<double> result;
     computeAverageByLayer( layerBoundaryIndexes, values, result );
     return result;
@@ -226,13 +226,13 @@ std::vector<double>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::findCurveAndComputeTopOfLayer( RiaDefines::CurveProperty curveProperty ) const
+std::vector<double> RimStimPlanModelCalculator::findCurveAndComputeTopOfLayer( RiaDefines::CurveProperty curveProperty ) const
 {
     std::vector<std::pair<double, double>> layerBoundaryDepths;
     std::vector<std::pair<size_t, size_t>> layerBoundaryIndexes;
     calculateLayers( layerBoundaryDepths, layerBoundaryIndexes );
 
-    std::vector<double> values = extractValues( curveProperty, m_fractureModel->timeStep() );
+    std::vector<double> values = extractValues( curveProperty, m_stimPlanModel->timeStep() );
     std::vector<double> result;
     extractTopOfLayerValues( layerBoundaryIndexes, values, result );
     return result;
@@ -241,7 +241,7 @@ std::vector<double> RimFractureModelCalculator::findCurveAndComputeTopOfLayer( R
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculatePorosity() const
+std::vector<double> RimStimPlanModelCalculator::calculatePorosity() const
 {
     return findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::POROSITY );
 }
@@ -249,7 +249,7 @@ std::vector<double> RimFractureModelCalculator::calculatePorosity() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateReservoirPressure() const
+std::vector<double> RimStimPlanModelCalculator::calculateReservoirPressure() const
 {
     std::vector<double> pressureBar = findCurveAndComputeTopOfLayer( RiaDefines::CurveProperty::PRESSURE );
 
@@ -265,7 +265,7 @@ std::vector<double> RimFractureModelCalculator::calculateReservoirPressure() con
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateHorizontalPermeability() const
+std::vector<double> RimStimPlanModelCalculator::calculateHorizontalPermeability() const
 {
     return findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::PERMEABILITY_X );
 }
@@ -273,7 +273,7 @@ std::vector<double> RimFractureModelCalculator::calculateHorizontalPermeability(
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateVerticalPermeability() const
+std::vector<double> RimStimPlanModelCalculator::calculateVerticalPermeability() const
 {
     return findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::PERMEABILITY_Z );
 }
@@ -281,7 +281,7 @@ std::vector<double> RimFractureModelCalculator::calculateVerticalPermeability()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateStress() const
+std::vector<double> RimStimPlanModelCalculator::calculateStress() const
 {
     std::vector<double> stress;
     std::vector<double> stressGradients;
@@ -293,7 +293,7 @@ std::vector<double> RimFractureModelCalculator::calculateStress() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateInitialStress() const
+std::vector<double> RimStimPlanModelCalculator::calculateInitialStress() const
 {
     std::vector<double> stress;
     std::vector<double> stressGradients;
@@ -305,20 +305,20 @@ std::vector<double> RimFractureModelCalculator::calculateInitialStress() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimFractureModelCalculator::calculateStressWithGradients( std::vector<double>& stress,
+bool RimStimPlanModelCalculator::calculateStressWithGradients( std::vector<double>& stress,
                                                                std::vector<double>& stressGradients,
                                                                std::vector<double>& initialStress ) const
 {
     // Reference stress
-    const double verticalStressRef         = m_fractureModel->verticalStress();
+    const double verticalStressRef         = m_stimPlanModel->verticalStress();
-    const double verticalStressGradientRef = m_fractureModel->verticalStressGradient();
+    const double verticalStressGradientRef = m_stimPlanModel->verticalStressGradient();
-    const double stressDepthRef            = m_fractureModel->stressDepth();
+    const double stressDepthRef            = m_stimPlanModel->stressDepth();
 
     std::vector<std::pair<double, double>> layerBoundaryDepths;
     std::vector<std::pair<size_t, size_t>> layerBoundaryIndexes;
     calculateLayers( layerBoundaryDepths, layerBoundaryIndexes );
 
-    int timeStep = m_fractureModel->timeStep();
+    int timeStep = m_stimPlanModel->timeStep();
 
     // Biot coefficient
     std::vector<double> biotData = extractValues( RiaDefines::CurveProperty::BIOT_COEFFICIENT, timeStep );
@@ -424,7 +424,7 @@ bool RimFractureModelCalculator::calculateStressWithGradients( std::vector<doubl
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateStressGradient() const
+std::vector<double> RimStimPlanModelCalculator::calculateStressGradient() const
 {
     std::vector<double> stress;
     std::vector<double> stressGradients;
@@ -436,16 +436,16 @@ std::vector<double> RimFractureModelCalculator::calculateStressGradient() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCalculator::calculateTemperature( std::vector<double>& temperatures ) const
+void RimStimPlanModelCalculator::calculateTemperature( std::vector<double>& temperatures ) const
 {
     // Reference temperature. Unit: degrees celsius
-    const double referenceTemperature = m_fractureModel->referenceTemperature();
+    const double referenceTemperature = m_stimPlanModel->referenceTemperature();
 
     // Reference temperature gradient. Unit: degrees Celsius per meter
-    const double referenceTemperatureGradient = m_fractureModel->referenceTemperatureGradient();
+    const double referenceTemperatureGradient = m_stimPlanModel->referenceTemperatureGradient();
 
     // Reference depth for temperature. Unit: meter.
-    const double referenceTemperatureDepth = m_fractureModel->referenceTemperatureDepth();
+    const double referenceTemperatureDepth = m_stimPlanModel->referenceTemperatureDepth();
 
     std::vector<std::pair<double, double>> layerBoundaryDepths;
     std::vector<std::pair<size_t, size_t>> layerBoundaryIndexes;
@@ -467,7 +467,7 @@ void RimFractureModelCalculator::calculateTemperature( std::vector<double>& temp
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateYoungsModulus() const
+std::vector<double> RimStimPlanModelCalculator::calculateYoungsModulus() const
 {
     std::vector<double> valuesGPa = findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::YOUNGS_MODULUS );
     std::vector<double> valuesMMpsi;
@@ -482,7 +482,7 @@ std::vector<double> RimFractureModelCalculator::calculateYoungsModulus() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculatePoissonsRatio() const
+std::vector<double> RimStimPlanModelCalculator::calculatePoissonsRatio() const
 {
     return findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::POISSONS_RATIO );
 }
@@ -490,7 +490,7 @@ std::vector<double> RimFractureModelCalculator::calculatePoissonsRatio() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateKIc() const
+std::vector<double> RimStimPlanModelCalculator::calculateKIc() const
 {
     return findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::K_IC );
 }
@@ -498,7 +498,7 @@ std::vector<double> RimFractureModelCalculator::calculateKIc() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateFluidLossCoefficient() const
+std::vector<double> RimStimPlanModelCalculator::calculateFluidLossCoefficient() const
 {
     return findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::FLUID_LOSS_COEFFICIENT );
 }
@@ -506,7 +506,7 @@ std::vector<double> RimFractureModelCalculator::calculateFluidLossCoefficient()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateSpurtLoss() const
+std::vector<double> RimStimPlanModelCalculator::calculateSpurtLoss() const
 {
     return findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::SPURT_LOSS );
 }
@@ -514,7 +514,7 @@ std::vector<double> RimFractureModelCalculator::calculateSpurtLoss() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateProppandEmbedment() const
+std::vector<double> RimStimPlanModelCalculator::calculateProppandEmbedment() const
 {
     return findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::PROPPANT_EMBEDMENT );
 }
@@ -522,7 +522,7 @@ std::vector<double> RimFractureModelCalculator::calculateProppandEmbedment() con
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateImmobileFluidSaturation() const
+std::vector<double> RimStimPlanModelCalculator::calculateImmobileFluidSaturation() const
 {
     return findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::IMMOBILE_FLUID_SATURATION );
 }
@@ -530,7 +530,7 @@ std::vector<double> RimFractureModelCalculator::calculateImmobileFluidSaturation
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateTemperature() const
+std::vector<double> RimStimPlanModelCalculator::calculateTemperature() const
 {
     std::vector<double> temperaturesCelsius;
     calculateTemperature( temperaturesCelsius );
@@ -548,7 +548,7 @@ std::vector<double> RimFractureModelCalculator::calculateTemperature() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateRelativePermeabilityFactor() const
+std::vector<double> RimStimPlanModelCalculator::calculateRelativePermeabilityFactor() const
 {
     return findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::RELATIVE_PERMEABILITY_FACTOR );
 }
@@ -556,7 +556,7 @@ std::vector<double> RimFractureModelCalculator::calculateRelativePermeabilityFac
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculatePoroElasticConstant() const
+std::vector<double> RimStimPlanModelCalculator::calculatePoroElasticConstant() const
 {
     return findCurveAndComputeLayeredAverage( RiaDefines::CurveProperty::PORO_ELASTIC_CONSTANT );
 }
@@ -564,7 +564,7 @@ std::vector<double> RimFractureModelCalculator::calculatePoroElasticConstant() c
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RimFractureModelCalculator::calculateThermalExpansionCoefficient() const
+std::vector<double> RimStimPlanModelCalculator::calculateThermalExpansionCoefficient() const
 {
     // SI unit is 1/Celsius
     std::vector<double> coefficientCelsius =

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelCalculator.h

@@ -17,22 +17,22 @@
 /////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
-#include "RimFractureModelPropertyCalculator.h"
+#include "RimStimPlanModelPropertyCalculator.h"
 
 #include <memory>
 #include <vector>
 
-class RimFractureModel;
+class RimStimPlanModel;
 
-class RimFractureModelCalculator
+class RimStimPlanModelCalculator
 {
 public:
-    RimFractureModelCalculator();
+    RimStimPlanModelCalculator();
 
-    void              setFractureModel( RimFractureModel* fractureModel );
+    void              setStimPlanModel( RimStimPlanModel* stimPlanModel );
-    RimFractureModel* fractureModel();
+    RimStimPlanModel* stimPlanModel();
 
     bool extractCurveData( RiaDefines::CurveProperty curveProperty,
                            int                       timeStep,
@@ -91,6 +91,6 @@ protected:
                                            std::vector<double>&                          result );
 
 private:
-    RimFractureModel*                                                m_fractureModel;
+    RimStimPlanModel*                                                m_stimPlanModel;
-    std::vector<std::unique_ptr<RimFractureModelPropertyCalculator>> m_resultCalculators;
+    std::vector<std::unique_ptr<RimStimPlanModelPropertyCalculator>> m_resultCalculators;
 };

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelCollection.cpp

@@ -16,72 +16,72 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RimFractureModelCollection.h"
+#include "RimStimPlanModelCollection.h"
 
-#include "RimFractureModel.h"
 #include "RimProject.h"
+#include "RimStimPlanModel.h"
 
 #include "cafPdmFieldScriptingCapability.h"
 #include "cafPdmObject.h"
 #include "cafPdmObjectScriptingCapability.h"
 
-CAF_PDM_SOURCE_INIT( RimFractureModelCollection, "FractureModelCollection" );
+CAF_PDM_SOURCE_INIT( RimStimPlanModelCollection, "StimPlanModelCollection" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelCollection::RimFractureModelCollection( void )
+RimStimPlanModelCollection::RimStimPlanModelCollection( void )
 {
-    CAF_PDM_InitScriptableObject( "Fracture Models", "", "", "" );
+    CAF_PDM_InitScriptableObject( "StimPlan Models", "", "", "" );
 
-    CAF_PDM_InitScriptableFieldNoDefault( &m_fractureModels, "FractureModels", "", "", "", "" );
+    CAF_PDM_InitScriptableFieldNoDefault( &m_stimPlanModels, "StimPlanModels", "", "", "", "" );
-    m_fractureModels.uiCapability()->setUiHidden( true );
+    m_stimPlanModels.uiCapability()->setUiHidden( true );
 
-    setName( "Fracture Models" );
+    setName( "StimPlan Models" );
     nameField()->uiCapability()->setUiHidden( true );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelCollection::~RimFractureModelCollection()
+RimStimPlanModelCollection::~RimStimPlanModelCollection()
 {
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCollection::addFractureModel( RimFractureModel* fracture )
+void RimStimPlanModelCollection::addStimPlanModel( RimStimPlanModel* fracture )
 {
-    m_fractureModels.push_back( fracture );
+    m_stimPlanModels.push_back( fracture );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCollection::deleteFractureModels()
+void RimStimPlanModelCollection::deleteStimPlanModels()
 {
-    m_fractureModels.deleteAllChildObjects();
+    m_stimPlanModels.deleteAllChildObjects();
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RimFractureModel*> RimFractureModelCollection::allFractureModels() const
+std::vector<RimStimPlanModel*> RimStimPlanModelCollection::allStimPlanModels() const
 {
-    return m_fractureModels.childObjects();
+    return m_stimPlanModels.childObjects();
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RimFractureModel*> RimFractureModelCollection::activeFractureModels() const
+std::vector<RimStimPlanModel*> RimStimPlanModelCollection::activeStimPlanModels() const
 {
-    std::vector<RimFractureModel*> active;
+    std::vector<RimStimPlanModel*> active;
 
     if ( isChecked() )
     {
-        for ( const auto& f : allFractureModels() )
+        for ( const auto& f : allStimPlanModels() )
         {
             if ( f->isChecked() )
             {
@@ -96,7 +96,7 @@ std::vector<RimFractureModel*> RimFractureModelCollection::activeFractureModels(
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCollection::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
+void RimStimPlanModelCollection::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
     uiOrdering.skipRemainingFields( true );
 }
@@ -104,7 +104,7 @@ void RimFractureModelCollection::defineUiOrdering( QString uiConfigName, caf::Pd
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCollection::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
+void RimStimPlanModelCollection::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
                                                    const QVariant&            oldValue,
                                                    const QVariant&            newValue )
 {

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelCollection.h

@@ -24,30 +24,30 @@
 
 #include <vector>
 
-class RimFractureModel;
+class RimStimPlanModel;
 
 //==================================================================================================
 ///
 ///
 //==================================================================================================
-class RimFractureModelCollection : public RimCheckableNamedObject
+class RimStimPlanModelCollection : public RimCheckableNamedObject
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimFractureModelCollection( void );
+    RimStimPlanModelCollection( void );
-    ~RimFractureModelCollection( void ) override;
+    ~RimStimPlanModelCollection( void ) override;
 
-    void addFractureModel( RimFractureModel* fracture );
+    void addStimPlanModel( RimStimPlanModel* fracture );
-    void deleteFractureModels();
+    void deleteStimPlanModels();
 
-    std::vector<RimFractureModel*> allFractureModels() const;
+    std::vector<RimStimPlanModel*> allStimPlanModels() const;
-    std::vector<RimFractureModel*> activeFractureModels() const;
+    std::vector<RimStimPlanModel*> activeStimPlanModels() const;
 
 private:
     void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
     void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
 
 private:
-    caf::PdmChildArrayField<RimFractureModel*> m_fractureModels;
+    caf::PdmChildArrayField<RimStimPlanModel*> m_stimPlanModels;
 };

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelCurve.cpp

@@ -16,40 +16,40 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RimFractureModelCurve.h"
+#include "RimStimPlanModelCurve.h"
 
 #include "RiaApplication.h"
-#include "RiaFractureModelDefines.h"
 #include "RiaInterpolationTools.h"
 #include "RiaLogging.h"
 #include "RiaPreferences.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "RigEclipseCaseData.h"
 
 #include "RimEclipseCase.h"
 #include "RimEclipseResultDefinition.h"
-#include "RimFractureModel.h"
-#include "RimFractureModelCalculator.h"
-#include "RimFractureModelPlot.h"
 #include "RimModeledWellPath.h"
+#include "RimStimPlanModel.h"
+#include "RimStimPlanModelCalculator.h"
+#include "RimStimPlanModelPlot.h"
 
 #include "RiuQwtPlotCurve.h"
 #include "RiuQwtPlotWidget.h"
 
 #include "cafPdmUiTreeOrdering.h"
 
-CAF_PDM_SOURCE_INIT( RimFractureModelCurve, "FractureModelCurve" );
+CAF_PDM_SOURCE_INIT( RimStimPlanModelCurve, "StimPlanModelCurve" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelCurve::RimFractureModelCurve()
+RimStimPlanModelCurve::RimStimPlanModelCurve()
 {
-    CAF_PDM_InitObject( "Fracture Model Curve", "", "", "" );
+    CAF_PDM_InitObject( "StimPlan Model Curve", "", "", "" );
 
-    CAF_PDM_InitFieldNoDefault( &m_fractureModel, "FractureModel", "Fracture Model", "", "", "" );
+    CAF_PDM_InitFieldNoDefault( &m_stimPlanModel, "StimPlanModel", "StimPlan Model", "", "", "" );
-    m_fractureModel.uiCapability()->setUiTreeChildrenHidden( true );
+    m_stimPlanModel.uiCapability()->setUiTreeChildrenHidden( true );
-    m_fractureModel.uiCapability()->setUiHidden( true );
+    m_stimPlanModel.uiCapability()->setUiHidden( true );
 
     CAF_PDM_InitFieldNoDefault( &m_curveProperty, "CurveProperty", "Curve Property", "", "", "" );
     m_curveProperty.uiCapability()->setUiHidden( true );
@@ -60,25 +60,25 @@ RimFractureModelCurve::RimFractureModelCurve()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelCurve::~RimFractureModelCurve()
+RimStimPlanModelCurve::~RimStimPlanModelCurve()
 {
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCurve::setFractureModel( RimFractureModel* fractureModel )
+void RimStimPlanModelCurve::setStimPlanModel( RimStimPlanModel* stimPlanModel )
 {
-    m_fractureModel = fractureModel;
+    m_stimPlanModel = stimPlanModel;
-    m_case          = fractureModel->eclipseCase();
+    m_case          = stimPlanModel->eclipseCase();
-    m_timeStep      = fractureModel->timeStep();
+    m_timeStep      = stimPlanModel->timeStep();
-    m_wellPath      = fractureModel->thicknessDirectionWellPath();
+    m_wellPath      = stimPlanModel->thicknessDirectionWellPath();
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCurve::setEclipseResultCategory( RiaDefines::ResultCatType catType )
+void RimStimPlanModelCurve::setEclipseResultCategory( RiaDefines::ResultCatType catType )
 {
     m_eclipseResultDefinition->setResultType( catType );
 }
@@ -86,7 +86,7 @@ void RimFractureModelCurve::setEclipseResultCategory( RiaDefines::ResultCatType
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCurve::setCurveProperty( RiaDefines::CurveProperty curveProperty )
+void RimStimPlanModelCurve::setCurveProperty( RiaDefines::CurveProperty curveProperty )
 {
     m_curveProperty = curveProperty;
 }
@@ -94,7 +94,7 @@ void RimFractureModelCurve::setCurveProperty( RiaDefines::CurveProperty curvePro
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RiaDefines::CurveProperty RimFractureModelCurve::curveProperty() const
+RiaDefines::CurveProperty RimStimPlanModelCurve::curveProperty() const
 {
     return m_curveProperty();
 }
@@ -102,24 +102,24 @@ RiaDefines::CurveProperty RimFractureModelCurve::curveProperty() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCurve::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
+void RimStimPlanModelCurve::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
                                               const QVariant&            oldValue,
                                               const QVariant&            newValue )
 {
     RimWellLogExtractionCurve::fieldChangedByUi( changedField, oldValue, newValue );
-    RimFractureModelPlot* fractureModelPlot;
+    RimStimPlanModelPlot* stimPlanModelPlot;
-    firstAncestorOrThisOfTypeAsserted( fractureModelPlot );
+    firstAncestorOrThisOfTypeAsserted( stimPlanModelPlot );
 
-    if ( fractureModelPlot )
+    if ( stimPlanModelPlot )
     {
-        fractureModelPlot->loadDataAndUpdate();
+        stimPlanModelPlot->loadDataAndUpdate();
     }
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
+void RimStimPlanModelCurve::performDataExtraction( bool* isUsingPseudoLength )
 {
     std::vector<double> values;
     std::vector<double> measuredDepthValues;
@@ -131,12 +131,12 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
 
     *isUsingPseudoLength = false;
 
-    if ( m_fractureModel && m_fractureModel->eclipseCase() )
+    if ( m_stimPlanModel && m_stimPlanModel->eclipseCase() )
     {
-        RimEclipseCase* eclipseCase = m_fractureModel->eclipseCase();
+        RimEclipseCase* eclipseCase = m_stimPlanModel->eclipseCase();
 
-        bool isOk = m_fractureModel->calculator()->extractCurveData( curveProperty(),
+        bool isOk = m_stimPlanModel->calculator()->extractCurveData( curveProperty(),
-                                                                     m_fractureModel->timeStep(),
+                                                                     m_stimPlanModel->timeStep(),
                                                                      values,
                                                                      measuredDepthValues,
                                                                      tvDepthValues,
@@ -165,7 +165,7 @@ void RimFractureModelCurve::performDataExtraction( bool* isUsingPseudoLength )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimFractureModelCurve::createCurveAutoName()
+QString RimStimPlanModelCurve::createCurveAutoName()
 {
     return caf::AppEnum<RiaDefines::CurveProperty>::uiText( m_curveProperty() );
 }

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelCurve.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include "RimFractureModelPropertyCurve.h"
+#include "RimStimPlanModelPropertyCurve.h"
 #include "RimWellLogExtractionCurve.h"
 
 #include "cafPdmField.h"
@@ -26,20 +26,20 @@
 
 #include <vector>
 
-class RimFractureModel;
+class RimStimPlanModel;
 
 //==================================================================================================
 ///
 //==================================================================================================
-class RimFractureModelCurve : public RimWellLogExtractionCurve, public RimFractureModelPropertyCurve
+class RimStimPlanModelCurve : public RimWellLogExtractionCurve, public RimStimPlanModelPropertyCurve
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimFractureModelCurve();
+    RimStimPlanModelCurve();
-    ~RimFractureModelCurve() override;
+    ~RimStimPlanModelCurve() override;
 
-    void setFractureModel( RimFractureModel* fractureModel );
+    void setStimPlanModel( RimStimPlanModel* stimPlanModel );
 
     void setEclipseResultCategory( RiaDefines::ResultCatType catType );
 
@@ -53,6 +53,6 @@ protected:
 
     QString createCurveAutoName();
 
-    caf::PdmPtrField<RimFractureModel*>                    m_fractureModel;
+    caf::PdmPtrField<RimStimPlanModel*>                    m_stimPlanModel;
     caf::PdmField<caf::AppEnum<RiaDefines::CurveProperty>> m_curveProperty;
 };

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelElasticPropertyCalculator.cpp

@@ -15,12 +15,12 @@
 //  for more details.
 //
 /////////////////////////////////////////////////////////////////////////////////
-#include "RimFractureModelElasticPropertyCalculator.h"
+#include "RimStimPlanModelElasticPropertyCalculator.h"
 
 #include "RiaDefines.h"
-#include "RiaFractureModelDefines.h"
 #include "RiaInterpolationTools.h"
 #include "RiaLogging.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "RigEclipseCaseData.h"
 #include "RigEclipseWellLogExtractor.h"
@@ -39,12 +39,12 @@
 #include "RimEclipseResultDefinition.h"
 #include "RimElasticProperties.h"
 #include "RimFaciesProperties.h"
-#include "RimFractureModel.h"
-#include "RimFractureModelCalculator.h"
-#include "RimFractureModelElasticPropertyCalculator.h"
-#include "RimFractureModelTemplate.h"
 #include "RimModeledWellPath.h"
 #include "RimNonNetLayers.h"
+#include "RimStimPlanModel.h"
+#include "RimStimPlanModelCalculator.h"
+#include "RimStimPlanModelElasticPropertyCalculator.h"
+#include "RimStimPlanModelTemplate.h"
 #include "RimTools.h"
 #include "RimWellLogFile.h"
 #include "RimWellLogPlot.h"
@@ -56,16 +56,16 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelElasticPropertyCalculator::RimFractureModelElasticPropertyCalculator(
+RimStimPlanModelElasticPropertyCalculator::RimStimPlanModelElasticPropertyCalculator(
-    RimFractureModelCalculator* fractureModelCalculator )
+    RimStimPlanModelCalculator* stimPlanModelCalculator )
-    : m_fractureModelCalculator( fractureModelCalculator )
+    : m_stimPlanModelCalculator( stimPlanModelCalculator )
 {
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimFractureModelElasticPropertyCalculator::isMatching( RiaDefines::CurveProperty curveProperty ) const
+bool RimStimPlanModelElasticPropertyCalculator::isMatching( RiaDefines::CurveProperty curveProperty ) const
 {
     std::vector<RiaDefines::CurveProperty> matching = {RiaDefines::CurveProperty::YOUNGS_MODULUS,
                                                        RiaDefines::CurveProperty::POISSONS_RATIO,
@@ -86,26 +86,26 @@ bool RimFractureModelElasticPropertyCalculator::isMatching( RiaDefines::CurvePro
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimFractureModelElasticPropertyCalculator::calculate( RiaDefines::CurveProperty curveProperty,
+bool RimStimPlanModelElasticPropertyCalculator::calculate( RiaDefines::CurveProperty curveProperty,
-                                                           const RimFractureModel*   fractureModel,
+                                                           const RimStimPlanModel*   stimPlanModel,
                                                            int                       timeStep,
                                                            std::vector<double>&      values,
                                                            std::vector<double>&      measuredDepthValues,
                                                            std::vector<double>&      tvDepthValues,
                                                            double&                   rkbDiff ) const
 {
-    RimEclipseCase* eclipseCase = fractureModel->eclipseCase();
+    RimEclipseCase* eclipseCase = stimPlanModel->eclipseCase();
     if ( !eclipseCase )
     {
         return false;
     }
 
-    if ( !fractureModel->thicknessDirectionWellPath() )
+    if ( !stimPlanModel->thicknessDirectionWellPath() )
     {
         return false;
     }
 
-    RigWellPath* wellPathGeometry = fractureModel->thicknessDirectionWellPath()->wellPathGeometry();
+    RigWellPath* wellPathGeometry = stimPlanModel->thicknessDirectionWellPath()->wellPathGeometry();
     if ( !wellPathGeometry )
     {
         RiaLogging::error( "No well path geometry found for layer data exctration." );
@@ -139,14 +139,14 @@ bool RimFractureModelElasticPropertyCalculator::calculate( RiaDefines::CurveProp
 
     std::vector<QString> formationNamesVector = RimWellLogTrack::formationNamesVector( eclipseCase );
 
-    RimFractureModelTemplate* fractureModelTemplate = fractureModel->fractureModelTemplate();
+    RimStimPlanModelTemplate* stimPlanModelTemplate = stimPlanModel->stimPlanModelTemplate();
-    if ( !fractureModelTemplate )
+    if ( !stimPlanModelTemplate )
     {
         RiaLogging::error( QString( "No fracture model template found" ) );
         return false;
     }
 
-    RimFaciesProperties* faciesProperties = fractureModelTemplate->faciesProperties();
+    RimFaciesProperties* faciesProperties = stimPlanModelTemplate->faciesProperties();
     if ( !faciesProperties )
     {
         RiaLogging::error( QString( "No facies properties found when extracting elastic properties." ) );
@@ -160,7 +160,7 @@ bool RimFractureModelElasticPropertyCalculator::calculate( RiaDefines::CurveProp
         return false;
     }
 
-    RimElasticProperties* elasticProperties = fractureModelTemplate->elasticProperties();
+    RimElasticProperties* elasticProperties = stimPlanModelTemplate->elasticProperties();
     if ( !elasticProperties )
     {
         RiaLogging::error( QString( "No elastic properties found" ) );
@@ -168,7 +168,7 @@ bool RimFractureModelElasticPropertyCalculator::calculate( RiaDefines::CurveProp
     }
 
     std::vector<double> faciesValues =
-        m_fractureModelCalculator->extractValues( RiaDefines::CurveProperty::FACIES, timeStep );
+        m_stimPlanModelCalculator->extractValues( RiaDefines::CurveProperty::FACIES, timeStep );
 
     if ( faciesValues.empty() )
     {
@@ -177,12 +177,12 @@ bool RimFractureModelElasticPropertyCalculator::calculate( RiaDefines::CurveProp
     }
 
     std::vector<double> poroValues =
-        m_fractureModelCalculator->extractValues( RiaDefines::CurveProperty::POROSITY, timeStep );
+        m_stimPlanModelCalculator->extractValues( RiaDefines::CurveProperty::POROSITY, timeStep );
 
-    double overburdenHeight = fractureModel->overburdenHeight();
+    double overburdenHeight = stimPlanModel->overburdenHeight();
     if ( overburdenHeight > 0.0 )
     {
-        QString overburdenFormation = fractureModel->overburdenFormation();
+        QString overburdenFormation = stimPlanModel->overburdenFormation();
         addOverburden( formationNamesVector,
                        formationValues,
                        tvDepthValues,
@@ -191,10 +191,10 @@ bool RimFractureModelElasticPropertyCalculator::calculate( RiaDefines::CurveProp
                        overburdenFormation );
     }
 
-    double underburdenHeight = fractureModel->underburdenHeight();
+    double underburdenHeight = stimPlanModel->underburdenHeight();
     if ( underburdenHeight > 0.0 )
     {
-        QString underburdenFormation = fractureModel->underburdenFormation();
+        QString underburdenFormation = stimPlanModel->underburdenFormation();
         addUnderburden( formationNamesVector,
                         formationValues,
                         tvDepthValues,
@@ -204,7 +204,7 @@ bool RimFractureModelElasticPropertyCalculator::calculate( RiaDefines::CurveProp
     }
 
     std::vector<double> netToGrossValues =
-        m_fractureModelCalculator->extractValues( RiaDefines::CurveProperty::NET_TO_GROSS, timeStep );
+        m_stimPlanModelCalculator->extractValues( RiaDefines::CurveProperty::NET_TO_GROSS, timeStep );
 
     CAF_ASSERT( tvDepthValues.size() == faciesValues.size() );
     CAF_ASSERT( tvDepthValues.size() == poroValues.size() );
@@ -214,12 +214,12 @@ bool RimFractureModelElasticPropertyCalculator::calculate( RiaDefines::CurveProp
     double  netToGrossCutoff        = 1.0;
     QString netToGrossFaciesName    = "";
     QString netToGrossFormationName = "";
-    if ( fractureModel->fractureModelTemplate() && fractureModel->fractureModelTemplate()->nonNetLayers() )
+    if ( stimPlanModel->stimPlanModelTemplate() && stimPlanModel->stimPlanModelTemplate()->nonNetLayers() )
     {
-        isScaledByNetToGross = fractureModel->isScaledByNetToGross( curveProperty ) && !netToGrossValues.empty() &&
+        isScaledByNetToGross = stimPlanModel->isScaledByNetToGross( curveProperty ) && !netToGrossValues.empty() &&
-                               fractureModel->fractureModelTemplate()->nonNetLayers()->isChecked();
+                               stimPlanModel->stimPlanModelTemplate()->nonNetLayers()->isChecked();
-        netToGrossCutoff     = fractureModel->fractureModelTemplate()->nonNetLayers()->cutOff();
+        netToGrossCutoff     = stimPlanModel->stimPlanModelTemplate()->nonNetLayers()->cutOff();
-        netToGrossFaciesName = fractureModel->fractureModelTemplate()->nonNetLayers()->facies();
+        netToGrossFaciesName = stimPlanModel->stimPlanModelTemplate()->nonNetLayers()->facies();
     }
 
     for ( size_t i = 0; i < tvDepthValues.size(); i++ )
@@ -258,9 +258,9 @@ bool RimFractureModelElasticPropertyCalculator::calculate( RiaDefines::CurveProp
 
                 values.push_back( val );
             }
-            else if ( fractureModel->hasDefaultValueForProperty( curveProperty ) )
+            else if ( stimPlanModel->hasDefaultValueForProperty( curveProperty ) )
             {
-                double val = fractureModel->getDefaultValueForProperty( curveProperty );
+                double val = stimPlanModel->getDefaultValueForProperty( curveProperty );
                 values.push_back( val );
             }
         }
@@ -281,7 +281,7 @@ bool RimFractureModelElasticPropertyCalculator::calculate( RiaDefines::CurveProp
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimFractureModelElasticPropertyCalculator::findFaciesName( const RimColorLegend& colorLegend, double value )
+QString RimStimPlanModelElasticPropertyCalculator::findFaciesName( const RimColorLegend& colorLegend, double value )
 {
     for ( auto item : colorLegend.colorLegendItems() )
     {
@@ -294,7 +294,7 @@ QString RimFractureModelElasticPropertyCalculator::findFaciesName( const RimColo
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelElasticPropertyCalculator::addOverburden( std::vector<QString>& formationNames,
+void RimStimPlanModelElasticPropertyCalculator::addOverburden( std::vector<QString>& formationNames,
                                                                std::vector<double>&  formationValues,
                                                                std::vector<double>&  tvDepthValues,
                                                                std::vector<double>&  measuredDepthValues,
@@ -323,7 +323,7 @@ void RimFractureModelElasticPropertyCalculator::addOverburden( std::vector<QStri
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelElasticPropertyCalculator::addUnderburden( std::vector<QString>& formationNames,
+void RimStimPlanModelElasticPropertyCalculator::addUnderburden( std::vector<QString>& formationNames,
                                                                 std::vector<double>&  formationValues,
                                                                 std::vector<double>&  tvDepthValues,
                                                                 std::vector<double>&  measuredDepthValues,

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelElasticPropertyCalculator.h

@@ -17,25 +17,25 @@
 /////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
-#include "RimFractureModelPropertyCalculator.h"
+#include "RimStimPlanModelPropertyCalculator.h"
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include <vector>
 
-class RimFractureModelCalculator;
+class RimStimPlanModelCalculator;
-class RimFractureModel;
+class RimStimPlanModel;
 class RimColorLegend;
 
 class QString;
 
-class RimFractureModelElasticPropertyCalculator : public RimFractureModelPropertyCalculator
+class RimStimPlanModelElasticPropertyCalculator : public RimStimPlanModelPropertyCalculator
 {
 public:
-    RimFractureModelElasticPropertyCalculator( RimFractureModelCalculator* calculator );
+    RimStimPlanModelElasticPropertyCalculator( RimStimPlanModelCalculator* calculator );
 
     bool calculate( RiaDefines::CurveProperty curveProperty,
-                    const RimFractureModel*   fractureModel,
+                    const RimStimPlanModel*   stimPlanModel,
                     int                       timeStep,
                     std::vector<double>&      values,
                     std::vector<double>&      measuredDepthValues,
@@ -62,5 +62,5 @@ protected:
     static QString findFaciesName( const RimColorLegend& colorLegend, double value );
 
 private:
-    RimFractureModelCalculator* m_fractureModelCalculator;
+    RimStimPlanModelCalculator* m_stimPlanModelCalculator;
 };

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelLayerCalculator.cpp

@@ -15,11 +15,11 @@
 //  for more details.
 //
 /////////////////////////////////////////////////////////////////////////////////
-#include "RimFractureModelLayerCalculator.h"
+#include "RimStimPlanModelLayerCalculator.h"
 
 #include "RiaDefines.h"
-#include "RiaFractureModelDefines.h"
 #include "RiaLogging.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "RigEclipseCaseData.h"
 #include "RigEclipseWellLogExtractor.h"
@@ -30,12 +30,12 @@
 #include "RimCase.h"
 #include "RimEclipseCase.h"
 #include "RimEclipseResultDefinition.h"
-#include "RimFractureModel.h"
-#include "RimFractureModelCalculator.h"
-#include "RimFractureModelLayerCalculator.h"
-#include "RimFractureModelTemplate.h"
 #include "RimModeledWellPath.h"
 #include "RimNonNetLayers.h"
+#include "RimStimPlanModel.h"
+#include "RimStimPlanModelCalculator.h"
+#include "RimStimPlanModelLayerCalculator.h"
+#include "RimStimPlanModelTemplate.h"
 #include "RimWellLogTrack.h"
 #include "RimWellPath.h"
 
@@ -44,15 +44,15 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelLayerCalculator::RimFractureModelLayerCalculator( RimFractureModelCalculator* fractureModelCalculator )
+RimStimPlanModelLayerCalculator::RimStimPlanModelLayerCalculator( RimStimPlanModelCalculator* stimPlanModelCalculator )
-    : m_fractureModelCalculator( fractureModelCalculator )
+    : m_stimPlanModelCalculator( stimPlanModelCalculator )
 {
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimFractureModelLayerCalculator::isMatching( RiaDefines::CurveProperty curveProperty ) const
+bool RimStimPlanModelLayerCalculator::isMatching( RiaDefines::CurveProperty curveProperty ) const
 {
     return curveProperty == RiaDefines::CurveProperty::LAYERS;
 }
@@ -60,26 +60,26 @@ bool RimFractureModelLayerCalculator::isMatching( RiaDefines::CurveProperty curv
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimFractureModelLayerCalculator::calculate( RiaDefines::CurveProperty curveProperty,
+bool RimStimPlanModelLayerCalculator::calculate( RiaDefines::CurveProperty curveProperty,
-                                                 const RimFractureModel*   fractureModel,
+                                                 const RimStimPlanModel*   stimPlanModel,
                                                  int                       timeStep,
                                                  std::vector<double>&      values,
                                                  std::vector<double>&      measuredDepthValues,
                                                  std::vector<double>&      tvDepthValues,
                                                  double&                   rkbDiff ) const
 {
-    RimEclipseCase* eclipseCase = fractureModel->eclipseCase();
+    RimEclipseCase* eclipseCase = stimPlanModel->eclipseCase();
     if ( !eclipseCase )
     {
         return false;
     }
 
-    if ( !fractureModel->thicknessDirectionWellPath() )
+    if ( !stimPlanModel->thicknessDirectionWellPath() )
     {
         return false;
     }
 
-    RigWellPath* wellPathGeometry = fractureModel->thicknessDirectionWellPath()->wellPathGeometry();
+    RigWellPath* wellPathGeometry = stimPlanModel->thicknessDirectionWellPath()->wellPathGeometry();
     if ( !wellPathGeometry )
     {
         RiaLogging::error( "No well path geometry found for layer data exctration." );
@@ -109,13 +109,13 @@ bool RimFractureModelLayerCalculator::calculate( RiaDefines::CurveProperty curve
 
     std::vector<QString> formationNamesVector = RimWellLogTrack::formationNamesVector( eclipseCase );
 
-    double overburdenHeight = fractureModel->overburdenHeight();
+    double overburdenHeight = stimPlanModel->overburdenHeight();
     if ( overburdenHeight > 0.0 )
     {
         RimWellLogTrack::addOverburden( formationNamesVector, curveData, overburdenHeight );
     }
 
-    double underburdenHeight = fractureModel->underburdenHeight();
+    double underburdenHeight = stimPlanModel->underburdenHeight();
     if ( underburdenHeight > 0.0 )
     {
         RimWellLogTrack::addUnderburden( formationNamesVector, curveData, underburdenHeight );
@@ -123,7 +123,7 @@ bool RimFractureModelLayerCalculator::calculate( RiaDefines::CurveProperty curve
 
     // Extract facies data
     std::vector<double> faciesValues =
-        m_fractureModelCalculator->extractValues( RiaDefines::CurveProperty::FACIES, timeStep );
+        m_stimPlanModelCalculator->extractValues( RiaDefines::CurveProperty::FACIES, timeStep );
     if ( faciesValues.empty() )
     {
         RiaLogging::error( QString( "Empty facies data found for layer curve." ) );
@@ -131,7 +131,7 @@ bool RimFractureModelLayerCalculator::calculate( RiaDefines::CurveProperty curve
     }
 
     std::vector<double> netToGrossValues =
-        m_fractureModelCalculator->extractValues( RiaDefines::CurveProperty::NET_TO_GROSS, timeStep );
+        m_stimPlanModelCalculator->extractValues( RiaDefines::CurveProperty::NET_TO_GROSS, timeStep );
     if ( netToGrossValues.empty() )
     {
         RiaLogging::warning( QString( "Empty net-to-gross data found for layer curve." ) );
@@ -151,10 +151,10 @@ bool RimFractureModelLayerCalculator::calculate( RiaDefines::CurveProperty curve
     double netToGrossCutoff   = 1.0;
     bool   useNetToGross      = false;
 
-    if ( fractureModel->fractureModelTemplate() && fractureModel->fractureModelTemplate()->nonNetLayers() )
+    if ( stimPlanModel->stimPlanModelTemplate() && stimPlanModel->stimPlanModelTemplate()->nonNetLayers() )
     {
-        netToGrossCutoff = fractureModel->fractureModelTemplate()->nonNetLayers()->cutOff();
+        netToGrossCutoff = stimPlanModel->stimPlanModelTemplate()->nonNetLayers()->cutOff();
-        useNetToGross = !netToGrossValues.empty() && fractureModel->fractureModelTemplate()->nonNetLayers()->isChecked();
+        useNetToGross = !netToGrossValues.empty() && stimPlanModel->stimPlanModelTemplate()->nonNetLayers()->isChecked();
     }
 
     for ( size_t i = 0; i < faciesValues.size(); i++ )

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelLayerCalculator.h

@@ -17,22 +17,22 @@
 /////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
-#include "RimFractureModelPropertyCalculator.h"
+#include "RimStimPlanModelPropertyCalculator.h"
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include <vector>
 
-class RimFractureModelCalculator;
+class RimStimPlanModelCalculator;
-class RimFractureModel;
+class RimStimPlanModel;
 
-class RimFractureModelLayerCalculator : public RimFractureModelPropertyCalculator
+class RimStimPlanModelLayerCalculator : public RimStimPlanModelPropertyCalculator
 {
 public:
-    RimFractureModelLayerCalculator( RimFractureModelCalculator* calculator );
+    RimStimPlanModelLayerCalculator( RimStimPlanModelCalculator* calculator );
 
     bool calculate( RiaDefines::CurveProperty curveProperty,
-                    const RimFractureModel*   fractureModel,
+                    const RimStimPlanModel*   stimPlanModel,
                     int                       timeStep,
                     std::vector<double>&      values,
                     std::vector<double>&      measuredDepthValues,
@@ -42,5 +42,5 @@ public:
     bool isMatching( RiaDefines::CurveProperty curveProperty ) const override;
 
 private:
-    RimFractureModelCalculator* m_fractureModelCalculator;
+    RimStimPlanModelCalculator* m_stimPlanModelCalculator;
 };

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelPlot.cpp

@@ -15,17 +15,17 @@
 //  for more details.
 //
 /////////////////////////////////////////////////////////////////////////////////
-#include "RimFractureModelPlot.h"
+#include "RimStimPlanModelPlot.h"
 
 #include "RiaDefines.h"
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "Riu3DMainWindowTools.h"
 
 #include "RimEclipseCase.h"
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
-#include "RimFractureModelCurve.h"
+#include "RimStimPlanModelCurve.h"
-#include "RimFractureModelPropertyCurve.h"
+#include "RimStimPlanModelPropertyCurve.h"
 #include "RimTools.h"
 #include "RimWellLogTrack.h"
 
@@ -36,21 +36,21 @@
 #include "cafPdmUiGroup.h"
 #include "cafPdmUiToolButtonEditor.h"
 
-CAF_PDM_SOURCE_INIT( RimFractureModelPlot, "FractureModelPlot" );
+CAF_PDM_SOURCE_INIT( RimStimPlanModelPlot, "StimPlanModelPlot" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelPlot::RimFractureModelPlot()
+RimStimPlanModelPlot::RimStimPlanModelPlot()
 {
-    CAF_PDM_InitScriptableObject( "Fracture Model Plot", "", "", "A fracture model plot" );
+    CAF_PDM_InitScriptableObject( "StimPlan Model Plot", "", "", "A fracture model plot" );
 
-    CAF_PDM_InitScriptableFieldNoDefault( &m_fractureModel, "FractureModel", "Fracture Model", "", "", "" );
+    CAF_PDM_InitScriptableFieldNoDefault( &m_stimPlanModel, "StimPlanModel", "StimPlan Model", "", "", "" );
-    m_fractureModel.uiCapability()->setUiReadOnly( true );
+    m_stimPlanModel.uiCapability()->setUiReadOnly( true );
 
-    CAF_PDM_InitField( &m_editFractureModel, "EditModel", false, "Edit", "", "", "" );
+    CAF_PDM_InitField( &m_editStimPlanModel, "EditModel", false, "Edit", "", "", "" );
-    m_editFractureModel.uiCapability()->setUiEditorTypeName( caf::PdmUiToolButtonEditor::uiEditorTypeName() );
+    m_editStimPlanModel.uiCapability()->setUiEditorTypeName( caf::PdmUiToolButtonEditor::uiEditorTypeName() );
-    m_editFractureModel.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::HIDDEN );
+    m_editStimPlanModel.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::HIDDEN );
 
     CAF_PDM_InitScriptableFieldNoDefault( &m_eclipseCase, "EclipseCase", "Case", "", "", "" );
     CAF_PDM_InitScriptableField( &m_timeStep, "TimeStep", 0, "Time Step", "", "", "" );
@@ -62,30 +62,30 @@ RimFractureModelPlot::RimFractureModelPlot()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelPlot::setFractureModel( RimFractureModel* fractureModel )
+void RimStimPlanModelPlot::setStimPlanModel( RimStimPlanModel* stimPlanModel )
 {
-    m_fractureModel = fractureModel;
+    m_stimPlanModel = stimPlanModel;
-    m_eclipseCase   = fractureModel->eclipseCase();
+    m_eclipseCase   = stimPlanModel->eclipseCase();
-    m_timeStep      = fractureModel->timeStep();
+    m_timeStep      = stimPlanModel->timeStep();
 
-    m_nameConfig->setCustomName( fractureModel->name() );
+    m_nameConfig->setCustomName( stimPlanModel->name() );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModel* RimFractureModelPlot::fractureModel()
+RimStimPlanModel* RimStimPlanModelPlot::stimPlanModel()
 {
-    return m_fractureModel;
+    return m_stimPlanModel;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelPlot::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
+void RimStimPlanModelPlot::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
-    uiOrdering.add( &m_fractureModel, {true, 2, 1} );
+    uiOrdering.add( &m_stimPlanModel, {true, 2, 1} );
-    uiOrdering.add( &m_editFractureModel, {false, 1, 0} );
+    uiOrdering.add( &m_editStimPlanModel, {false, 1, 0} );
     uiOrdering.add( &m_eclipseCase );
     uiOrdering.add( &m_timeStep );
 
@@ -105,14 +105,14 @@ void RimFractureModelPlot::defineUiOrdering( QString uiConfigName, caf::PdmUiOrd
 ///
 //--------------------------------------------------------------------------------------------------
 QList<caf::PdmOptionItemInfo>
-    RimFractureModelPlot::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly )
+    RimStimPlanModelPlot::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly )
 {
     QList<caf::PdmOptionItemInfo> options;
 
-    if ( fieldNeedingOptions == &m_fractureModel )
+    if ( fieldNeedingOptions == &m_stimPlanModel )
     {
         // The user is not allowed to change this field, but option box looks good
-        options.push_back( caf::PdmOptionItemInfo( m_fractureModel->name(), m_fractureModel ) );
+        options.push_back( caf::PdmOptionItemInfo( m_stimPlanModel->name(), m_stimPlanModel ) );
     }
     else if ( fieldNeedingOptions == &m_eclipseCase )
     {
@@ -129,22 +129,22 @@ QList<caf::PdmOptionItemInfo>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
+void RimStimPlanModelPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
                                              const QVariant&            oldValue,
                                              const QVariant&            newValue )
 {
-    if ( m_fractureModel )
+    if ( m_stimPlanModel )
     {
         if ( changedField == &m_eclipseCase || changedField == &m_timeStep )
         {
-            m_fractureModel->setEclipseCaseAndTimeStep( m_eclipseCase(), m_timeStep() );
+            m_stimPlanModel->setEclipseCaseAndTimeStep( m_eclipseCase(), m_timeStep() );
         }
-        else if ( changedField == &m_editFractureModel )
+        else if ( changedField == &m_editStimPlanModel )
         {
-            m_editFractureModel = false;
+            m_editStimPlanModel = false;
-            if ( m_fractureModel != nullptr )
+            if ( m_stimPlanModel != nullptr )
             {
-                Riu3DMainWindowTools::selectAsCurrentItem( m_fractureModel() );
+                Riu3DMainWindowTools::selectAsCurrentItem( m_stimPlanModel() );
             }
         }
     }
@@ -153,17 +153,17 @@ void RimFractureModelPlot::fieldChangedByUi( const caf::PdmFieldHandle* changedF
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelPlot::onLoadDataAndUpdate()
+void RimStimPlanModelPlot::onLoadDataAndUpdate()
 {
     // Enable and disable detailed fluid loss curves
-    if ( fractureModel() != nullptr )
+    if ( stimPlanModel() != nullptr )
     {
         std::vector<RiaDefines::CurveProperty> fluidLossCurves = {RiaDefines::CurveProperty::PORO_ELASTIC_CONSTANT,
                                                                   RiaDefines::CurveProperty::RELATIVE_PERMEABILITY_FACTOR,
                                                                   RiaDefines::CurveProperty::THERMAL_EXPANSION_COEFFICIENT,
                                                                   RiaDefines::CurveProperty::IMMOBILE_FLUID_SATURATION};
 
-        bool detailedFluidLoss = fractureModel()->useDetailedFluidLoss();
+        bool detailedFluidLoss = stimPlanModel()->useDetailedFluidLoss();
 
         for ( auto curveProperty : fluidLossCurves )
         {
@@ -186,7 +186,7 @@ void RimFractureModelPlot::onLoadDataAndUpdate()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelPlot::applyDataSource()
+void RimStimPlanModelPlot::applyDataSource()
 {
     this->updateConnectedEditors();
 }
@@ -194,12 +194,12 @@ void RimFractureModelPlot::applyDataSource()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellLogExtractionCurve* RimFractureModelPlot::findCurveByProperty( RiaDefines::CurveProperty curveProperty ) const
+RimWellLogExtractionCurve* RimStimPlanModelPlot::findCurveByProperty( RiaDefines::CurveProperty curveProperty ) const
 {
-    std::vector<RimFractureModelPropertyCurve*> curves;
+    std::vector<RimStimPlanModelPropertyCurve*> curves;
     descendantsIncludingThisOfType( curves );
 
-    for ( RimFractureModelPropertyCurve* curve : curves )
+    for ( RimStimPlanModelPropertyCurve* curve : curves )
     {
         if ( curve->curveProperty() == curveProperty )
         {

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelPlot.h

@@ -19,23 +19,23 @@
 
 #include "RimDepthTrackPlot.h"
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "cafPdmPtrField.h"
 
-class RimFractureModel;
+class RimStimPlanModel;
 class RimWellLogExtractionCurve;
 class RimEclipseCase;
 
-class RimFractureModelPlot : public RimDepthTrackPlot
+class RimStimPlanModelPlot : public RimDepthTrackPlot
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimFractureModelPlot();
+    RimStimPlanModelPlot();
 
-    void              setFractureModel( RimFractureModel* fractureModel );
+    void              setStimPlanModel( RimStimPlanModel* stimPlanModel );
-    RimFractureModel* fractureModel();
+    RimStimPlanModel* stimPlanModel();
 
 protected:
     RimWellLogExtractionCurve* findCurveByProperty( RiaDefines::CurveProperty curveProperty ) const;
@@ -50,8 +50,8 @@ protected:
 private:
     void applyDataSource();
 
-    caf::PdmPtrField<RimFractureModel*> m_fractureModel;
+    caf::PdmPtrField<RimStimPlanModel*> m_stimPlanModel;
-    caf::PdmField<bool>                 m_editFractureModel;
+    caf::PdmField<bool>                 m_editStimPlanModel;
     caf::PdmPtrField<RimEclipseCase*>   m_eclipseCase;
     caf::PdmField<int>                  m_timeStep;
 };

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelPlotCollection.cpp

@@ -16,40 +16,40 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RimFractureModelPlotCollection.h"
+#include "RimStimPlanModelPlotCollection.h"
 
-#include "RimFractureModelPlot.h"
+#include "RimStimPlanModelPlot.h"
 
 #include "cafPdmFieldScriptingCapability.h"
 #include "cafPdmObjectScriptingCapability.h"
 
-CAF_PDM_SOURCE_INIT( RimFractureModelPlotCollection, "FractureModelPlotCollection" );
+CAF_PDM_SOURCE_INIT( RimStimPlanModelPlotCollection, "StimPlanModelPlotCollection" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelPlotCollection::RimFractureModelPlotCollection()
+RimStimPlanModelPlotCollection::RimStimPlanModelPlotCollection()
 {
-    CAF_PDM_InitScriptableObject( "Fracture Model Plots", ":/WellLogPlots16x16.png", "", "" );
+    CAF_PDM_InitScriptableObject( "StimPlan Model Plots", ":/WellLogPlots16x16.png", "", "" );
 
-    CAF_PDM_InitScriptableFieldNoDefault( &m_fractureModelPlots, "FractureModelPlots", "", "", "", "" );
+    CAF_PDM_InitScriptableFieldNoDefault( &m_stimPlanModelPlots, "StimPlanModelPlots", "", "", "", "" );
-    m_fractureModelPlots.uiCapability()->setUiHidden( true );
+    m_stimPlanModelPlots.uiCapability()->setUiHidden( true );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelPlotCollection::~RimFractureModelPlotCollection()
+RimStimPlanModelPlotCollection::~RimStimPlanModelPlotCollection()
 {
-    m_fractureModelPlots.deleteAllChildObjects();
+    m_stimPlanModelPlots.deleteAllChildObjects();
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelPlotCollection::reloadAllPlots()
+void RimStimPlanModelPlotCollection::reloadAllPlots()
 {
-    for ( const auto& w : m_fractureModelPlots() )
+    for ( const auto& w : m_stimPlanModelPlots() )
     {
         w->loadDataAndUpdate();
     }
@@ -58,23 +58,23 @@ void RimFractureModelPlotCollection::reloadAllPlots()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelPlotCollection::addFractureModelPlot( RimFractureModelPlot* newPlot )
+void RimStimPlanModelPlotCollection::addStimPlanModelPlot( RimStimPlanModelPlot* newPlot )
 {
-    m_fractureModelPlots.push_back( newPlot );
+    m_stimPlanModelPlots.push_back( newPlot );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RimFractureModelPlot*> RimFractureModelPlotCollection::fractureModelPlots() const
+std::vector<RimStimPlanModelPlot*> RimStimPlanModelPlotCollection::stimPlanModelPlots() const
 {
-    return m_fractureModelPlots.childObjects();
+    return m_stimPlanModelPlots.childObjects();
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelPlotCollection::deleteAllPlots()
+void RimStimPlanModelPlotCollection::deleteAllPlots()
 {
-    m_fractureModelPlots.deleteAllChildObjects();
+    m_stimPlanModelPlots.deleteAllChildObjects();
 }

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelPlotCollection.h

@@ -22,28 +22,28 @@
 #include "cafPdmField.h"
 #include "cafPdmObject.h"
 
-class RimFractureModelPlot;
+class RimStimPlanModelPlot;
 
 //==================================================================================================
 ///
 ///
 //==================================================================================================
-class RimFractureModelPlotCollection : public caf::PdmObject
+class RimStimPlanModelPlotCollection : public caf::PdmObject
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimFractureModelPlotCollection();
+    RimStimPlanModelPlotCollection();
-    ~RimFractureModelPlotCollection() override;
+    ~RimStimPlanModelPlotCollection() override;
 
-    void addFractureModelPlot( RimFractureModelPlot* newPlot );
+    void addStimPlanModelPlot( RimStimPlanModelPlot* newPlot );
 
-    std::vector<RimFractureModelPlot*> fractureModelPlots() const;
+    std::vector<RimStimPlanModelPlot*> stimPlanModelPlots() const;
 
     void reloadAllPlots();
 
     void deleteAllPlots();
 
 private:
-    caf::PdmChildArrayField<RimFractureModelPlot*> m_fractureModelPlots;
+    caf::PdmChildArrayField<RimStimPlanModelPlot*> m_stimPlanModelPlots;
 };

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelPropertyCalculator.h

@@ -18,24 +18,24 @@
 
 #pragma once
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include <vector>
 
-class RimFractureModelCalculator;
+class RimStimPlanModelCalculator;
-class RimFractureModel;
+class RimStimPlanModel;
 
 //==================================================================================================
 ///
 //==================================================================================================
-class RimFractureModelPropertyCalculator
+class RimStimPlanModelPropertyCalculator
 {
 public:
-    virtual ~RimFractureModelPropertyCalculator(){};
+    virtual ~RimStimPlanModelPropertyCalculator(){};
 
     virtual bool isMatching( RiaDefines::CurveProperty curveProperty ) const = 0;
     virtual bool calculate( RiaDefines::CurveProperty curveProperty,
-                            const RimFractureModel*   fractureModel,
+                            const RimStimPlanModel*   stimPlanModel,
                             int                       timeStep,
                             std::vector<double>&      values,
                             std::vector<double>&      measuredDepthValues,

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelPropertyCurve.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "RimWellLogExtractionCurve.h"
 
@@ -27,7 +27,7 @@
 //==================================================================================================
 ///
 //==================================================================================================
-class RimFractureModelPropertyCurve
+class RimStimPlanModelPropertyCurve
 {
 public:
     virtual void                      setCurveProperty( RiaDefines::CurveProperty ) = 0;

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelStressCalculator.cpp

@@ -15,11 +15,11 @@
 //  for more details.
 //
 /////////////////////////////////////////////////////////////////////////////////
-#include "RimFractureModelStressCalculator.h"
+#include "RimStimPlanModelStressCalculator.h"
 
 #include "RiaDefines.h"
-#include "RiaFractureModelDefines.h"
 #include "RiaLogging.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "RigEclipseCaseData.h"
 #include "RigEclipseWellLogExtractor.h"
@@ -28,23 +28,23 @@
 #include "RigWellPathGeometryTools.h"
 #include "RimCase.h"
 #include "RimEclipseCase.h"
-#include "RimFractureModel.h"
-#include "RimFractureModelCalculator.h"
-#include "RimFractureModelStressCalculator.h"
 #include "RimModeledWellPath.h"
+#include "RimStimPlanModel.h"
+#include "RimStimPlanModelCalculator.h"
+#include "RimStimPlanModelStressCalculator.h"
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelStressCalculator::RimFractureModelStressCalculator( RimFractureModelCalculator* fractureModelCalculator )
+RimStimPlanModelStressCalculator::RimStimPlanModelStressCalculator( RimStimPlanModelCalculator* stimPlanModelCalculator )
-    : m_fractureModelCalculator( fractureModelCalculator )
+    : m_stimPlanModelCalculator( stimPlanModelCalculator )
 {
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimFractureModelStressCalculator::isMatching( RiaDefines::CurveProperty curveProperty ) const
+bool RimStimPlanModelStressCalculator::isMatching( RiaDefines::CurveProperty curveProperty ) const
 {
     std::vector<RiaDefines::CurveProperty> matching = {RiaDefines::CurveProperty::INITIAL_STRESS,
                                                        RiaDefines::CurveProperty::STRESS,
@@ -57,33 +57,33 @@ bool RimFractureModelStressCalculator::isMatching( RiaDefines::CurveProperty cur
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimFractureModelStressCalculator::calculate( RiaDefines::CurveProperty curveProperty,
+bool RimStimPlanModelStressCalculator::calculate( RiaDefines::CurveProperty curveProperty,
-                                                  const RimFractureModel*   fractureModel,
+                                                  const RimStimPlanModel*   stimPlanModel,
                                                   int                       timeStep,
                                                   std::vector<double>&      values,
                                                   std::vector<double>&      measuredDepthValues,
                                                   std::vector<double>&      tvDepthValues,
                                                   double&                   rkbDiff ) const
 {
-    RimEclipseCase* eclipseCase = fractureModel->eclipseCase();
+    RimEclipseCase* eclipseCase = stimPlanModel->eclipseCase();
     if ( !eclipseCase )
     {
         return false;
     }
 
-    if ( !fractureModel->thicknessDirectionWellPath() )
+    if ( !stimPlanModel->thicknessDirectionWellPath() )
     {
         return false;
     }
 
-    RigWellPath* wellPathGeometry = fractureModel->thicknessDirectionWellPath()->wellPathGeometry();
+    RigWellPath* wellPathGeometry = stimPlanModel->thicknessDirectionWellPath()->wellPathGeometry();
     if ( !wellPathGeometry )
     {
         RiaLogging::error( "No well path geometry found for stress data exctration." );
         return false;
     }
 
-    std::vector<double> tvDepthInFeet = m_fractureModelCalculator->calculateTrueVerticalDepth();
+    std::vector<double> tvDepthInFeet = m_stimPlanModelCalculator->calculateTrueVerticalDepth();
     for ( double f : tvDepthInFeet )
     {
         tvDepthValues.push_back( RiaEclipseUnitTools::feetToMeter( f ) );
@@ -91,23 +91,23 @@ bool RimFractureModelStressCalculator::calculate( RiaDefines::CurveProperty curv
 
     if ( curveProperty == RiaDefines::CurveProperty::STRESS )
     {
-        values                              = m_fractureModelCalculator->calculateStress();
+        values                              = m_stimPlanModelCalculator->calculateStress();
-        std::vector<double> stressGradients = m_fractureModelCalculator->calculateStressGradient();
+        std::vector<double> stressGradients = m_stimPlanModelCalculator->calculateStressGradient();
         addDatapointsForBottomOfLayers( tvDepthValues, values, stressGradients );
     }
     else if ( curveProperty == RiaDefines::CurveProperty::INITIAL_STRESS )
     {
-        values                              = m_fractureModelCalculator->calculateInitialStress();
+        values                              = m_stimPlanModelCalculator->calculateInitialStress();
-        std::vector<double> stressGradients = m_fractureModelCalculator->calculateStressGradient();
+        std::vector<double> stressGradients = m_stimPlanModelCalculator->calculateStressGradient();
         addDatapointsForBottomOfLayers( tvDepthValues, values, stressGradients );
     }
     else if ( curveProperty == RiaDefines::CurveProperty::STRESS_GRADIENT )
     {
-        values = m_fractureModelCalculator->calculateStressGradient();
+        values = m_stimPlanModelCalculator->calculateStressGradient();
     }
     else if ( curveProperty == RiaDefines::CurveProperty::TEMPERATURE )
     {
-        m_fractureModelCalculator->calculateTemperature( values );
+        m_stimPlanModelCalculator->calculateTemperature( values );
     }
 
     if ( eclipseCase )
@@ -136,7 +136,7 @@ bool RimFractureModelStressCalculator::calculate( RiaDefines::CurveProperty curv
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelStressCalculator::addDatapointsForBottomOfLayers( std::vector<double>&       tvDepthValues,
+void RimStimPlanModelStressCalculator::addDatapointsForBottomOfLayers( std::vector<double>&       tvDepthValues,
                                                                        std::vector<double>&       stress,
                                                                        const std::vector<double>& stressGradients )
 {

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelStressCalculator.h

@@ -17,24 +17,24 @@
 /////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
-#include "RimFractureModelPropertyCalculator.h"
+#include "RimStimPlanModelPropertyCalculator.h"
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include <vector>
 
-class RimFractureModelCalculator;
+class RimStimPlanModelCalculator;
-class RimFractureModel;
+class RimStimPlanModel;
 
 class QString;
 
-class RimFractureModelStressCalculator : public RimFractureModelPropertyCalculator
+class RimStimPlanModelStressCalculator : public RimStimPlanModelPropertyCalculator
 {
 public:
-    RimFractureModelStressCalculator( RimFractureModelCalculator* calculator );
+    RimStimPlanModelStressCalculator( RimStimPlanModelCalculator* calculator );
 
     bool calculate( RiaDefines::CurveProperty curveProperty,
-                    const RimFractureModel*   fractureModel,
+                    const RimStimPlanModel*   stimPlanModel,
                     int                       timeStep,
                     std::vector<double>&      values,
                     std::vector<double>&      measuredDepthValues,
@@ -48,5 +48,5 @@ private:
                                                 std::vector<double>&       stress,
                                                 const std::vector<double>& stressGradients );
 
-    RimFractureModelCalculator* m_fractureModelCalculator;
+    RimStimPlanModelCalculator* m_stimPlanModelCalculator;
 };

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelTemplate.cpp

@@ -16,14 +16,14 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RimFractureModelTemplate.h"
+#include "RimStimPlanModelTemplate.h"
 
 #include "RiaColorTables.h"
 #include "RiaCompletionTypeCalculationScheduler.h"
 #include "RiaEclipseUnitTools.h"
 #include "RiaFractureDefines.h"
-#include "RiaFractureModelDefines.h"
 #include "RiaLogging.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "Riu3DMainWindowTools.h"
 
@@ -41,10 +41,10 @@
 #include "RimElasticProperties.h"
 #include "RimEllipseFractureTemplate.h"
 #include "RimFaciesProperties.h"
-#include "RimFractureModelPlot.h"
 #include "RimNonNetLayers.h"
 #include "RimOilField.h"
 #include "RimProject.h"
+#include "RimStimPlanModelPlot.h"
 #include "RimTools.h"
 #include "RimWellPath.h"
 #include "RimWellPathCollection.h"
@@ -68,15 +68,15 @@
 
 #include <cmath>
 
-CAF_PDM_SOURCE_INIT( RimFractureModelTemplate, "FractureModelTemplate" );
+CAF_PDM_SOURCE_INIT( RimStimPlanModelTemplate, "StimPlanModelTemplate" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelTemplate::RimFractureModelTemplate()
+RimStimPlanModelTemplate::RimStimPlanModelTemplate()
     : changed( this )
 {
-    CAF_PDM_InitScriptableObject( "FractureModelTemplate", "", "", "" );
+    CAF_PDM_InitScriptableObject( "StimPlanModelTemplate", "", "", "" );
 
     CAF_PDM_InitScriptableField( &m_id, "Id", -1, "ID", "", "", "" );
     m_id.uiCapability()->setUiReadOnly( true );
@@ -176,14 +176,14 @@ RimFractureModelTemplate::RimFractureModelTemplate()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelTemplate::~RimFractureModelTemplate()
+RimStimPlanModelTemplate::~RimStimPlanModelTemplate()
 {
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
+void RimStimPlanModelTemplate::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
                                                  const QVariant&            oldValue,
                                                  const QVariant&            newValue )
 {
@@ -194,7 +194,7 @@ void RimFractureModelTemplate::fieldChangedByUi( const caf::PdmFieldHandle* chan
 ///
 //--------------------------------------------------------------------------------------------------
 QList<caf::PdmOptionItemInfo>
-    RimFractureModelTemplate::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly )
+    RimStimPlanModelTemplate::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly )
 {
     QList<caf::PdmOptionItemInfo> options;
 
@@ -229,7 +229,7 @@ QList<caf::PdmOptionItemInfo>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
+void RimStimPlanModelTemplate::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
     uiOrdering.add( nameField() );
     uiOrdering.add( &m_id );
@@ -268,7 +268,7 @@ void RimFractureModelTemplate::defineUiOrdering( QString uiConfigName, caf::PdmU
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::defineEditorAttribute( const caf::PdmFieldHandle* field,
+void RimStimPlanModelTemplate::defineEditorAttribute( const caf::PdmFieldHandle* field,
                                                       QString                    uiConfigName,
                                                       caf::PdmUiEditorAttribute* attribute )
 {
@@ -286,7 +286,7 @@ void RimFractureModelTemplate::defineEditorAttribute( const caf::PdmFieldHandle*
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::setId( int id )
+void RimStimPlanModelTemplate::setId( int id )
 {
     m_id = id;
 }
@@ -294,7 +294,7 @@ void RimFractureModelTemplate::setId( int id )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-int RimFractureModelTemplate::id() const
+int RimStimPlanModelTemplate::id() const
 {
     return m_id;
 }
@@ -302,7 +302,7 @@ int RimFractureModelTemplate::id() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimElasticProperties* RimFractureModelTemplate::elasticProperties() const
+RimElasticProperties* RimStimPlanModelTemplate::elasticProperties() const
 {
     return m_elasticProperties;
 }
@@ -310,7 +310,7 @@ RimElasticProperties* RimFractureModelTemplate::elasticProperties() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::setElasticProperties( RimElasticProperties* elasticProperties )
+void RimStimPlanModelTemplate::setElasticProperties( RimElasticProperties* elasticProperties )
 {
     if ( m_elasticProperties )
     {
@@ -321,14 +321,14 @@ void RimFractureModelTemplate::setElasticProperties( RimElasticProperties* elast
 
     if ( m_elasticProperties )
     {
-        m_elasticProperties->changed.connect( this, &RimFractureModelTemplate::elasticPropertiesChanged );
+        m_elasticProperties->changed.connect( this, &RimStimPlanModelTemplate::elasticPropertiesChanged );
     }
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFaciesProperties* RimFractureModelTemplate::faciesProperties() const
+RimFaciesProperties* RimStimPlanModelTemplate::faciesProperties() const
 {
     return m_faciesProperties;
 }
@@ -336,7 +336,7 @@ RimFaciesProperties* RimFractureModelTemplate::faciesProperties() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::setFaciesProperties( RimFaciesProperties* faciesProperties )
+void RimStimPlanModelTemplate::setFaciesProperties( RimFaciesProperties* faciesProperties )
 {
     if ( m_faciesProperties )
     {
@@ -347,7 +347,7 @@ void RimFractureModelTemplate::setFaciesProperties( RimFaciesProperties* faciesP
 
     if ( m_faciesProperties )
     {
-        m_faciesProperties->changed.connect( this, &RimFractureModelTemplate::faciesPropertiesChanged );
+        m_faciesProperties->changed.connect( this, &RimStimPlanModelTemplate::faciesPropertiesChanged );
         RimEclipseCase* eclipseCase = getEclipseCase();
         if ( !eclipseCase ) return;
 
@@ -358,7 +358,7 @@ void RimFractureModelTemplate::setFaciesProperties( RimFaciesProperties* faciesP
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::setNonNetLayers( RimNonNetLayers* nonNetLayers )
+void RimStimPlanModelTemplate::setNonNetLayers( RimNonNetLayers* nonNetLayers )
 {
     if ( m_nonNetLayers )
     {
@@ -369,7 +369,7 @@ void RimFractureModelTemplate::setNonNetLayers( RimNonNetLayers* nonNetLayers )
 
     if ( m_nonNetLayers )
     {
-        m_nonNetLayers->changed.connect( this, &RimFractureModelTemplate::nonNetLayersChanged );
+        m_nonNetLayers->changed.connect( this, &RimStimPlanModelTemplate::nonNetLayersChanged );
         RimEclipseCase* eclipseCase = getEclipseCase();
         if ( !eclipseCase ) return;
 
@@ -380,7 +380,7 @@ void RimFractureModelTemplate::setNonNetLayers( RimNonNetLayers* nonNetLayers )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimNonNetLayers* RimFractureModelTemplate::nonNetLayers() const
+RimNonNetLayers* RimStimPlanModelTemplate::nonNetLayers() const
 {
     return m_nonNetLayers;
 }
@@ -388,7 +388,7 @@ RimNonNetLayers* RimFractureModelTemplate::nonNetLayers() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::initAfterRead()
+void RimStimPlanModelTemplate::initAfterRead()
 {
     RimEclipseCase* eclipseCase = getEclipseCase();
     if ( !eclipseCase ) return;
@@ -407,7 +407,7 @@ void RimFractureModelTemplate::initAfterRead()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::faciesPropertiesChanged( const caf::SignalEmitter* emitter )
+void RimStimPlanModelTemplate::faciesPropertiesChanged( const caf::SignalEmitter* emitter )
 {
     changed.send();
 }
@@ -415,7 +415,7 @@ void RimFractureModelTemplate::faciesPropertiesChanged( const caf::SignalEmitter
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::elasticPropertiesChanged( const caf::SignalEmitter* emitter )
+void RimStimPlanModelTemplate::elasticPropertiesChanged( const caf::SignalEmitter* emitter )
 {
     changed.send();
 }
@@ -423,7 +423,7 @@ void RimFractureModelTemplate::elasticPropertiesChanged( const caf::SignalEmitte
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::nonNetLayersChanged( const caf::SignalEmitter* emitter )
+void RimStimPlanModelTemplate::nonNetLayersChanged( const caf::SignalEmitter* emitter )
 {
     changed.send();
 }
@@ -431,7 +431,7 @@ void RimFractureModelTemplate::nonNetLayersChanged( const caf::SignalEmitter* em
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplate::loadDataAndUpdate()
+void RimStimPlanModelTemplate::loadDataAndUpdate()
 {
     if ( m_elasticProperties )
     {
@@ -447,7 +447,7 @@ void RimFractureModelTemplate::loadDataAndUpdate()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::defaultPorosity() const
+double RimStimPlanModelTemplate::defaultPorosity() const
 {
     return m_defaultPorosity();
 }
@@ -455,7 +455,7 @@ double RimFractureModelTemplate::defaultPorosity() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::defaultPermeability() const
+double RimStimPlanModelTemplate::defaultPermeability() const
 {
     return m_defaultPermeability();
 }
@@ -463,7 +463,7 @@ double RimFractureModelTemplate::defaultPermeability() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::overburdenFluidDensity() const
+double RimStimPlanModelTemplate::overburdenFluidDensity() const
 {
     return m_overburdenFluidDensity;
 }
@@ -471,7 +471,7 @@ double RimFractureModelTemplate::overburdenFluidDensity() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::underburdenFluidDensity() const
+double RimStimPlanModelTemplate::underburdenFluidDensity() const
 {
     return m_underburdenFluidDensity;
 }
@@ -479,7 +479,7 @@ double RimFractureModelTemplate::underburdenFluidDensity() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::overburdenHeight() const
+double RimStimPlanModelTemplate::overburdenHeight() const
 {
     return m_overburdenHeight;
 }
@@ -487,7 +487,7 @@ double RimFractureModelTemplate::overburdenHeight() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::underburdenHeight() const
+double RimStimPlanModelTemplate::underburdenHeight() const
 {
     return m_underburdenHeight;
 }
@@ -495,7 +495,7 @@ double RimFractureModelTemplate::underburdenHeight() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::defaultOverburdenPorosity() const
+double RimStimPlanModelTemplate::defaultOverburdenPorosity() const
 {
     return m_overburdenPorosity;
 }
@@ -503,7 +503,7 @@ double RimFractureModelTemplate::defaultOverburdenPorosity() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::defaultUnderburdenPorosity() const
+double RimStimPlanModelTemplate::defaultUnderburdenPorosity() const
 {
     return m_underburdenPorosity;
 }
@@ -511,7 +511,7 @@ double RimFractureModelTemplate::defaultUnderburdenPorosity() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::defaultOverburdenPermeability() const
+double RimStimPlanModelTemplate::defaultOverburdenPermeability() const
 {
     return m_overburdenPermeability;
 }
@@ -519,7 +519,7 @@ double RimFractureModelTemplate::defaultOverburdenPermeability() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::defaultUnderburdenPermeability() const
+double RimStimPlanModelTemplate::defaultUnderburdenPermeability() const
 {
     return m_underburdenPermeability;
 }
@@ -527,7 +527,7 @@ double RimFractureModelTemplate::defaultUnderburdenPermeability() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimFractureModelTemplate::overburdenFormation() const
+QString RimStimPlanModelTemplate::overburdenFormation() const
 {
     return m_overburdenFormation;
 }
@@ -535,7 +535,7 @@ QString RimFractureModelTemplate::overburdenFormation() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimFractureModelTemplate::overburdenFacies() const
+QString RimStimPlanModelTemplate::overburdenFacies() const
 {
     return m_overburdenFacies;
 }
@@ -543,7 +543,7 @@ QString RimFractureModelTemplate::overburdenFacies() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimFractureModelTemplate::underburdenFormation() const
+QString RimStimPlanModelTemplate::underburdenFormation() const
 {
     return m_underburdenFormation;
 }
@@ -551,7 +551,7 @@ QString RimFractureModelTemplate::underburdenFormation() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimFractureModelTemplate::underburdenFacies() const
+QString RimStimPlanModelTemplate::underburdenFacies() const
 {
     return m_underburdenFacies;
 }
@@ -559,7 +559,7 @@ QString RimFractureModelTemplate::underburdenFacies() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::verticalStress() const
+double RimStimPlanModelTemplate::verticalStress() const
 {
     return m_verticalStress;
 }
@@ -567,7 +567,7 @@ double RimFractureModelTemplate::verticalStress() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::verticalStressGradient() const
+double RimStimPlanModelTemplate::verticalStressGradient() const
 {
     return m_verticalStressGradient;
 }
@@ -575,7 +575,7 @@ double RimFractureModelTemplate::verticalStressGradient() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::stressDepth() const
+double RimStimPlanModelTemplate::stressDepth() const
 {
     return m_stressDepth;
 }
@@ -583,7 +583,7 @@ double RimFractureModelTemplate::stressDepth() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::referenceTemperature() const
+double RimStimPlanModelTemplate::referenceTemperature() const
 {
     return m_referenceTemperature;
 }
@@ -591,7 +591,7 @@ double RimFractureModelTemplate::referenceTemperature() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::referenceTemperatureGradient() const
+double RimStimPlanModelTemplate::referenceTemperatureGradient() const
 {
     return m_referenceTemperatureGradient;
 }
@@ -599,7 +599,7 @@ double RimFractureModelTemplate::referenceTemperatureGradient() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::referenceTemperatureDepth() const
+double RimStimPlanModelTemplate::referenceTemperatureDepth() const
 {
     return m_referenceTemperatureDepth;
 }
@@ -607,7 +607,7 @@ double RimFractureModelTemplate::referenceTemperatureDepth() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimFractureModelTemplate::computeDefaultStressDepth()
+double RimStimPlanModelTemplate::computeDefaultStressDepth()
 {
     const double stressDepth = 1000.0;
 
@@ -621,7 +621,7 @@ double RimFractureModelTemplate::computeDefaultStressDepth()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimEclipseCase* RimFractureModelTemplate::getEclipseCase()
+RimEclipseCase* RimStimPlanModelTemplate::getEclipseCase()
 {
     // Find an eclipse case
     RimProject* proj = RimProject::current();
@@ -633,7 +633,7 @@ RimEclipseCase* RimFractureModelTemplate::getEclipseCase()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RigEclipseCaseData* RimFractureModelTemplate::getEclipseCaseData()
+RigEclipseCaseData* RimStimPlanModelTemplate::getEclipseCaseData()
 {
     // Find an eclipse case
     RimEclipseCase* eclipseCase = getEclipseCase();

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelTemplate.h

@@ -19,7 +19,7 @@
 #pragma once
 
 #include "RiaEclipseUnitTools.h"
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "RimNamedObject.h"
 
@@ -39,13 +39,13 @@ class RimNonNetLayers;
 ///
 ///
 //==================================================================================================
-class RimFractureModelTemplate : public RimNamedObject
+class RimStimPlanModelTemplate : public RimNamedObject
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimFractureModelTemplate( void );
+    RimStimPlanModelTemplate( void );
-    ~RimFractureModelTemplate( void ) override;
+    ~RimStimPlanModelTemplate( void ) override;
 
     caf::Signal<> changed;
 

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelTemplateCollection.cpp

@@ -16,35 +16,35 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RimFractureModelTemplateCollection.h"
+#include "RimStimPlanModelTemplateCollection.h"
 
 #include "RimCase.h"
 #include "RimEclipseCase.h"
 #include "RimEclipseView.h"
 #include "RimFracture.h"
-#include "RimFractureModelTemplate.h"
 #include "RimProject.h"
+#include "RimStimPlanModelTemplate.h"
 
 #include "cafPdmFieldScriptingCapability.h"
 #include "cafPdmObject.h"
 #include "cafPdmObjectScriptingCapability.h"
 
-CAF_PDM_SOURCE_INIT( RimFractureModelTemplateCollection, "FractureModelTemplateCollection" );
+CAF_PDM_SOURCE_INIT( RimStimPlanModelTemplateCollection, "StimPlanModelTemplateCollection" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelTemplateCollection::RimFractureModelTemplateCollection()
+RimStimPlanModelTemplateCollection::RimStimPlanModelTemplateCollection()
 {
-    CAF_PDM_InitScriptableObject( "Fracture Model Templates", ":/FractureTemplates16x16.png", "", "" );
+    CAF_PDM_InitScriptableObject( "StimPlan Model Templates", ":/FractureTemplates16x16.png", "", "" );
 
-    CAF_PDM_InitScriptableFieldNoDefault( &m_fractureModelTemplates,
+    CAF_PDM_InitScriptableFieldNoDefault( &m_stimPlanModelTemplates,
-                                          "FractureModelTemplates",
+                                          "StimPlanModelTemplates",
-                                          "Fracture Model Templates",
+                                          "StimPlan Model Templates",
                                           "",
                                           "",
                                           "" );
-    m_fractureModelTemplates.uiCapability()->setUiHidden( true );
+    m_stimPlanModelTemplates.uiCapability()->setUiHidden( true );
 
     CAF_PDM_InitField( &m_nextValidId, "NextValidId", 0, "", "", "", "" );
     m_nextValidId.uiCapability()->setUiHidden( true );
@@ -53,17 +53,17 @@ RimFractureModelTemplateCollection::RimFractureModelTemplateCollection()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelTemplateCollection::~RimFractureModelTemplateCollection()
+RimStimPlanModelTemplateCollection::~RimStimPlanModelTemplateCollection()
 {
-    m_fractureModelTemplates.deleteAllChildObjects();
+    m_stimPlanModelTemplates.deleteAllChildObjects();
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelTemplate* RimFractureModelTemplateCollection::fractureModelTemplate( int id ) const
+RimStimPlanModelTemplate* RimStimPlanModelTemplateCollection::stimPlanModelTemplate( int id ) const
 {
-    for ( const auto& templ : m_fractureModelTemplates )
+    for ( const auto& templ : m_stimPlanModelTemplates )
     {
         if ( templ->id() == id ) return templ;
     }
@@ -73,10 +73,10 @@ RimFractureModelTemplate* RimFractureModelTemplateCollection::fractureModelTempl
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RimFractureModelTemplate*> RimFractureModelTemplateCollection::fractureModelTemplates() const
+std::vector<RimStimPlanModelTemplate*> RimStimPlanModelTemplateCollection::stimPlanModelTemplates() const
 {
-    std::vector<RimFractureModelTemplate*> templates;
+    std::vector<RimStimPlanModelTemplate*> templates;
-    for ( auto& templ : m_fractureModelTemplates )
+    for ( auto& templ : m_stimPlanModelTemplates )
     {
         templates.push_back( templ );
     }
@@ -86,18 +86,18 @@ std::vector<RimFractureModelTemplate*> RimFractureModelTemplateCollection::fract
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplateCollection::addFractureModelTemplate( RimFractureModelTemplate* templ )
+void RimStimPlanModelTemplateCollection::addStimPlanModelTemplate( RimStimPlanModelTemplate* templ )
 {
     templ->setId( nextFractureTemplateId() );
-    m_fractureModelTemplates.push_back( templ );
+    m_stimPlanModelTemplates.push_back( templ );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplateCollection::loadAndUpdateData()
+void RimStimPlanModelTemplateCollection::loadAndUpdateData()
 {
-    for ( RimFractureModelTemplate* f : m_fractureModelTemplates() )
+    for ( RimStimPlanModelTemplate* f : m_stimPlanModelTemplates() )
     {
         f->loadDataAndUpdate();
     }
@@ -106,10 +106,10 @@ void RimFractureModelTemplateCollection::loadAndUpdateData()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplateCollection::initAfterRead()
+void RimStimPlanModelTemplateCollection::initAfterRead()
 {
     // Assign template id if not already assigned
-    for ( auto& templ : m_fractureModelTemplates )
+    for ( auto& templ : m_stimPlanModelTemplates )
     {
         if ( templ->id() < 0 ) templ->setId( nextFractureTemplateId() );
     }
@@ -118,7 +118,7 @@ void RimFractureModelTemplateCollection::initAfterRead()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-int RimFractureModelTemplateCollection::nextFractureTemplateId()
+int RimStimPlanModelTemplateCollection::nextFractureTemplateId()
 {
     int newId     = m_nextValidId;
     m_nextValidId = m_nextValidId + 1;
@@ -129,7 +129,7 @@ int RimFractureModelTemplateCollection::nextFractureTemplateId()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelTemplateCollection::onChildDeleted( caf::PdmChildArrayFieldHandle*      childArray,
+void RimStimPlanModelTemplateCollection::onChildDeleted( caf::PdmChildArrayFieldHandle*      childArray,
                                                          std::vector<caf::PdmObjectHandle*>& referringObjects )
 {
     RimProject* proj = nullptr;

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelTemplateCollection.h

@@ -22,23 +22,23 @@
 #include "cafPdmField.h"
 #include "cafPdmObject.h"
 
-class RimFractureModelTemplate;
+class RimStimPlanModelTemplate;
 
 //==================================================================================================
 ///
 ///
 //==================================================================================================
-class RimFractureModelTemplateCollection : public caf::PdmObject
+class RimStimPlanModelTemplateCollection : public caf::PdmObject
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimFractureModelTemplateCollection();
+    RimStimPlanModelTemplateCollection();
-    ~RimFractureModelTemplateCollection() override;
+    ~RimStimPlanModelTemplateCollection() override;
 
-    RimFractureModelTemplate*              fractureModelTemplate( int id ) const;
+    RimStimPlanModelTemplate*              stimPlanModelTemplate( int id ) const;
-    std::vector<RimFractureModelTemplate*> fractureModelTemplates() const;
+    std::vector<RimStimPlanModelTemplate*> stimPlanModelTemplates() const;
-    void                                   addFractureModelTemplate( RimFractureModelTemplate* templ );
+    void                                   addStimPlanModelTemplate( RimStimPlanModelTemplate* templ );
 
     void loadAndUpdateData();
 
@@ -51,6 +51,6 @@ protected:
 private:
     int nextFractureTemplateId();
 
-    caf::PdmChildArrayField<RimFractureModelTemplate*> m_fractureModelTemplates;
+    caf::PdmChildArrayField<RimStimPlanModelTemplate*> m_stimPlanModelTemplates;
     caf::PdmField<int>                                 m_nextValidId; // Unique fracture template ID within a project
 };

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelWellLogCalculator.cpp

@@ -15,12 +15,12 @@
 //  for more details.
 //
 /////////////////////////////////////////////////////////////////////////////////
-#include "RimFractureModelWellLogCalculator.h"
+#include "RimStimPlanModelWellLogCalculator.h"
 
 #include "RiaDefines.h"
-#include "RiaFractureModelDefines.h"
 #include "RiaInterpolationTools.h"
 #include "RiaLogging.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "RigEclipseCaseData.h"
 #include "RigEclipseWellLogExtractor.h"
@@ -34,25 +34,25 @@
 #include "RimEclipseInputProperty.h"
 #include "RimEclipseInputPropertyCollection.h"
 #include "RimEclipseResultDefinition.h"
-#include "RimFractureModel.h"
-#include "RimFractureModelCalculator.h"
-#include "RimFractureModelTemplate.h"
 #include "RimModeledWellPath.h"
 #include "RimNonNetLayers.h"
+#include "RimStimPlanModel.h"
+#include "RimStimPlanModelCalculator.h"
+#include "RimStimPlanModelTemplate.h"
 #include "RimWellPath.h"
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimFractureModelWellLogCalculator::RimFractureModelWellLogCalculator( RimFractureModelCalculator* fractureModelCalculator )
+RimStimPlanModelWellLogCalculator::RimStimPlanModelWellLogCalculator( RimStimPlanModelCalculator* stimPlanModelCalculator )
-    : m_fractureModelCalculator( fractureModelCalculator )
+    : m_stimPlanModelCalculator( stimPlanModelCalculator )
 {
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimFractureModelWellLogCalculator::isMatching( RiaDefines::CurveProperty curveProperty ) const
+bool RimStimPlanModelWellLogCalculator::isMatching( RiaDefines::CurveProperty curveProperty ) const
 {
     std::vector<RiaDefines::CurveProperty> matching = {
         RiaDefines::CurveProperty::FACIES,
@@ -70,26 +70,26 @@ bool RimFractureModelWellLogCalculator::isMatching( RiaDefines::CurveProperty cu
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimFractureModelWellLogCalculator::calculate( RiaDefines::CurveProperty curveProperty,
+bool RimStimPlanModelWellLogCalculator::calculate( RiaDefines::CurveProperty curveProperty,
-                                                   const RimFractureModel*   fractureModel,
+                                                   const RimStimPlanModel*   stimPlanModel,
                                                    int                       timeStep,
                                                    std::vector<double>&      values,
                                                    std::vector<double>&      measuredDepthValues,
                                                    std::vector<double>&      tvDepthValues,
                                                    double&                   rkbDiff ) const
 {
-    RimEclipseCase* eclipseCase = fractureModel->eclipseCase();
+    RimEclipseCase* eclipseCase = stimPlanModel->eclipseCase();
     if ( !eclipseCase )
     {
         return false;
     }
 
-    if ( !fractureModel->thicknessDirectionWellPath() )
+    if ( !stimPlanModel->thicknessDirectionWellPath() )
     {
         return false;
     }
 
-    RigWellPath* wellPathGeometry = fractureModel->thicknessDirectionWellPath()->wellPathGeometry();
+    RigWellPath* wellPathGeometry = stimPlanModel->thicknessDirectionWellPath()->wellPathGeometry();
     if ( !wellPathGeometry )
     {
         RiaLogging::error( "No well path geometry found for well log exctration" );
@@ -104,13 +104,13 @@ bool RimFractureModelWellLogCalculator::calculate( RiaDefines::CurveProperty cur
 
     RimEclipseResultDefinition eclipseResultDefinition;
     eclipseResultDefinition.setEclipseCase( eclipseCase );
-    eclipseResultDefinition.setResultType( fractureModel->eclipseResultCategory( curveProperty ) );
+    eclipseResultDefinition.setResultType( stimPlanModel->eclipseResultCategory( curveProperty ) );
     eclipseResultDefinition.setPorosityModel( RiaDefines::PorosityModelType::MATRIX_MODEL );
-    eclipseResultDefinition.setResultVariable( fractureModel->eclipseResultVariable( curveProperty ) );
+    eclipseResultDefinition.setResultVariable( stimPlanModel->eclipseResultVariable( curveProperty ) );
 
     eclipseResultDefinition.loadResult();
 
-    if ( fractureModel->eclipseResultCategory( curveProperty ) != RiaDefines::ResultCatType::DYNAMIC_NATIVE ||
+    if ( stimPlanModel->eclipseResultCategory( curveProperty ) != RiaDefines::ResultCatType::DYNAMIC_NATIVE ||
          curveProperty == RiaDefines::CurveProperty::INITIAL_PRESSURE )
     {
         timeStep = 0;
@@ -132,21 +132,21 @@ bool RimFractureModelWellLogCalculator::calculate( RiaDefines::CurveProperty cur
         return false;
     }
 
-    double overburdenHeight = fractureModel->overburdenHeight();
+    double overburdenHeight = stimPlanModel->overburdenHeight();
     if ( overburdenHeight > 0.0 )
     {
-        addOverburden( curveProperty, fractureModel, tvDepthValues, measuredDepthValues, values );
+        addOverburden( curveProperty, stimPlanModel, tvDepthValues, measuredDepthValues, values );
     }
 
-    double underburdenHeight = fractureModel->underburdenHeight();
+    double underburdenHeight = stimPlanModel->underburdenHeight();
     if ( underburdenHeight > 0.0 )
     {
-        addUnderburden( curveProperty, fractureModel, tvDepthValues, measuredDepthValues, values );
+        addUnderburden( curveProperty, stimPlanModel, tvDepthValues, measuredDepthValues, values );
     }
 
     if ( hasMissingValues( values ) )
     {
-        if ( fractureModel->missingValueStrategy( curveProperty ) == RimFractureModel::MissingValueStrategy::DEFAULT_VALUE )
+        if ( stimPlanModel->missingValueStrategy( curveProperty ) == RimStimPlanModel::MissingValueStrategy::DEFAULT_VALUE )
         {
             // Try to locate a backup accessor (e.g. PORO_1 for PORO)
             cvf::ref<RigResultAccessor> backupResAcc = findMissingValuesAccessor( eclipseCase->eclipseCaseData(),
@@ -162,26 +162,26 @@ bool RimFractureModelWellLogCalculator::calculate( RiaDefines::CurveProperty cur
                 std::vector<double> replacementValues;
                 eclExtractor.curveData( backupResAcc.p(), &replacementValues );
 
-                double overburdenHeight = fractureModel->overburdenHeight();
+                double overburdenHeight = stimPlanModel->overburdenHeight();
                 if ( overburdenHeight > 0.0 )
                 {
                     double defaultOverburdenValue = std::numeric_limits<double>::infinity();
-                    if ( fractureModel->burdenStrategy( curveProperty ) == RimFractureModel::BurdenStrategy::DEFAULT_VALUE )
+                    if ( stimPlanModel->burdenStrategy( curveProperty ) == RimStimPlanModel::BurdenStrategy::DEFAULT_VALUE )
                     {
-                        defaultOverburdenValue = fractureModel->getDefaultForMissingOverburdenValue( curveProperty );
+                        defaultOverburdenValue = stimPlanModel->getDefaultForMissingOverburdenValue( curveProperty );
                     }
 
                     replacementValues.insert( replacementValues.begin(), defaultOverburdenValue );
                     replacementValues.insert( replacementValues.begin(), defaultOverburdenValue );
                 }
 
-                double underburdenHeight = fractureModel->underburdenHeight();
+                double underburdenHeight = stimPlanModel->underburdenHeight();
                 if ( underburdenHeight > 0.0 )
                 {
                     double defaultUnderburdenValue = std::numeric_limits<double>::infinity();
-                    if ( fractureModel->burdenStrategy( curveProperty ) == RimFractureModel::BurdenStrategy::DEFAULT_VALUE )
+                    if ( stimPlanModel->burdenStrategy( curveProperty ) == RimStimPlanModel::BurdenStrategy::DEFAULT_VALUE )
                     {
-                        defaultUnderburdenValue = fractureModel->getDefaultForMissingUnderburdenValue( curveProperty );
+                        defaultUnderburdenValue = stimPlanModel->getDefaultForMissingUnderburdenValue( curveProperty );
                     }
 
                     replacementValues.push_back( defaultUnderburdenValue );
@@ -197,13 +197,13 @@ bool RimFractureModelWellLogCalculator::calculate( RiaDefines::CurveProperty cur
             {
                 RiaLogging::info( QString( "Using default value for %1" ).arg( eclipseResultDefinition.resultVariable() ) );
 
-                double defaultValue = fractureModel->getDefaultForMissingValue( curveProperty );
+                double defaultValue = stimPlanModel->getDefaultForMissingValue( curveProperty );
 
                 replaceMissingValues( values, defaultValue );
             }
         }
-        else if ( fractureModel->missingValueStrategy( curveProperty ) ==
+        else if ( stimPlanModel->missingValueStrategy( curveProperty ) ==
-                  RimFractureModel::MissingValueStrategy::LINEAR_INTERPOLATION )
+                  RimStimPlanModel::MissingValueStrategy::LINEAR_INTERPOLATION )
         {
             RiaLogging::info(
                 QString( "Interpolating missing values for %1" ).arg( eclipseResultDefinition.resultVariable() ) );
@@ -213,13 +213,13 @@ bool RimFractureModelWellLogCalculator::calculate( RiaDefines::CurveProperty cur
         {
             // Get the missing data from other curve
             RiaDefines::CurveProperty replacementProperty =
-                fractureModel->getDefaultPropertyForMissingValues( curveProperty );
+                stimPlanModel->getDefaultPropertyForMissingValues( curveProperty );
 
             std::vector<double> initialValues;
             std::vector<double> initialMds;
             std::vector<double> initialTvds;
             double              initialRkbDiff = -1.0;
-            calculate( replacementProperty, fractureModel, timeStep, initialValues, initialMds, initialTvds, initialRkbDiff );
+            calculate( replacementProperty, stimPlanModel, timeStep, initialValues, initialMds, initialTvds, initialRkbDiff );
 
             if ( initialValues.empty() )
             {
@@ -232,12 +232,12 @@ bool RimFractureModelWellLogCalculator::calculate( RiaDefines::CurveProperty cur
         }
     }
 
-    if ( fractureModel->isScaledByNetToGross( curveProperty ) )
+    if ( stimPlanModel->isScaledByNetToGross( curveProperty ) )
     {
         std::vector<double> netToGross =
-            m_fractureModelCalculator->extractValues( RiaDefines::CurveProperty::NET_TO_GROSS, timeStep );
+            m_stimPlanModelCalculator->extractValues( RiaDefines::CurveProperty::NET_TO_GROSS, timeStep );
 
-        scaleByNetToGross( fractureModel, netToGross, values );
+        scaleByNetToGross( stimPlanModel, netToGross, values );
     }
 
     return true;
@@ -246,7 +246,7 @@ bool RimFractureModelWellLogCalculator::calculate( RiaDefines::CurveProperty cur
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimFractureModelWellLogCalculator::hasMissingValues( const std::vector<double>& values )
+bool RimStimPlanModelWellLogCalculator::hasMissingValues( const std::vector<double>& values )
 {
     for ( double v : values )
     {
@@ -262,7 +262,7 @@ bool RimFractureModelWellLogCalculator::hasMissingValues( const std::vector<doub
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelWellLogCalculator::replaceMissingValues( std::vector<double>& values, double defaultValue )
+void RimStimPlanModelWellLogCalculator::replaceMissingValues( std::vector<double>& values, double defaultValue )
 {
     for ( double& v : values )
     {
@@ -276,7 +276,7 @@ void RimFractureModelWellLogCalculator::replaceMissingValues( std::vector<double
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelWellLogCalculator::replaceMissingValues( std::vector<double>&       values,
+void RimStimPlanModelWellLogCalculator::replaceMissingValues( std::vector<double>&       values,
                                                               const std::vector<double>& replacementValues )
 {
     CVF_ASSERT( values.size() == replacementValues.size() );
@@ -293,7 +293,7 @@ void RimFractureModelWellLogCalculator::replaceMissingValues( std::vector<double
 ///
 //--------------------------------------------------------------------------------------------------
 cvf::ref<RigResultAccessor>
-    RimFractureModelWellLogCalculator::findMissingValuesAccessor( RigEclipseCaseData*                caseData,
+    RimStimPlanModelWellLogCalculator::findMissingValuesAccessor( RigEclipseCaseData*                caseData,
                                                                   RimEclipseInputPropertyCollection* inputPropertyCollection,
                                                                   int                                gridIndex,
                                                                   int                                timeStepIndex,
@@ -328,28 +328,28 @@ cvf::ref<RigResultAccessor>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelWellLogCalculator::addOverburden( RiaDefines::CurveProperty curveProperty,
+void RimStimPlanModelWellLogCalculator::addOverburden( RiaDefines::CurveProperty curveProperty,
-                                                       const RimFractureModel*   fractureModel,
+                                                       const RimStimPlanModel*   stimPlanModel,
                                                        std::vector<double>&      tvDepthValues,
                                                        std::vector<double>&      measuredDepthValues,
                                                        std::vector<double>&      values ) const
 {
     if ( !values.empty() )
     {
-        double overburdenHeight    = fractureModel->overburdenHeight();
+        double overburdenHeight    = stimPlanModel->overburdenHeight();
         double tvdOverburdenBottom = tvDepthValues[0];
         double tvdOverburdenTop    = tvdOverburdenBottom - overburdenHeight;
 
         double overburdenTopValue    = std::numeric_limits<double>::infinity();
         double overburdenBottomValue = std::numeric_limits<double>::infinity();
-        if ( fractureModel->burdenStrategy( curveProperty ) == RimFractureModel::BurdenStrategy::DEFAULT_VALUE )
+        if ( stimPlanModel->burdenStrategy( curveProperty ) == RimStimPlanModel::BurdenStrategy::DEFAULT_VALUE )
         {
-            overburdenTopValue    = fractureModel->getDefaultForMissingOverburdenValue( curveProperty );
+            overburdenTopValue    = stimPlanModel->getDefaultForMissingOverburdenValue( curveProperty );
             overburdenBottomValue = overburdenTopValue;
         }
         else
         {
-            double gradient       = fractureModel->getOverburdenGradient( curveProperty );
+            double gradient       = stimPlanModel->getOverburdenGradient( curveProperty );
             overburdenBottomValue = values[0];
             overburdenTopValue    = overburdenBottomValue + gradient * -overburdenHeight;
         }
@@ -371,8 +371,8 @@ void RimFractureModelWellLogCalculator::addOverburden( RiaDefines::CurveProperty
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelWellLogCalculator::addUnderburden( RiaDefines::CurveProperty curveProperty,
+void RimStimPlanModelWellLogCalculator::addUnderburden( RiaDefines::CurveProperty curveProperty,
-                                                        const RimFractureModel*   fractureModel,
+                                                        const RimStimPlanModel*   stimPlanModel,
                                                         std::vector<double>&      tvDepthValues,
                                                         std::vector<double>&      measuredDepthValues,
                                                         std::vector<double>&      values ) const
@@ -381,20 +381,20 @@ void RimFractureModelWellLogCalculator::addUnderburden( RiaDefines::CurvePropert
     {
         size_t lastIndex = tvDepthValues.size() - 1;
 
-        double underburdenHeight    = fractureModel->underburdenHeight();
+        double underburdenHeight    = stimPlanModel->underburdenHeight();
         double tvdUnderburdenTop    = tvDepthValues[lastIndex];
         double tvdUnderburdenBottom = tvdUnderburdenTop + underburdenHeight;
 
         double underburdenTopValue    = std::numeric_limits<double>::infinity();
         double underburdenBottomValue = std::numeric_limits<double>::infinity();
-        if ( fractureModel->burdenStrategy( curveProperty ) == RimFractureModel::BurdenStrategy::DEFAULT_VALUE )
+        if ( stimPlanModel->burdenStrategy( curveProperty ) == RimStimPlanModel::BurdenStrategy::DEFAULT_VALUE )
         {
-            underburdenTopValue    = fractureModel->getDefaultForMissingUnderburdenValue( curveProperty );
+            underburdenTopValue    = stimPlanModel->getDefaultForMissingUnderburdenValue( curveProperty );
             underburdenBottomValue = underburdenTopValue;
         }
         else
         {
-            double gradient        = fractureModel->getUnderburdenGradient( curveProperty );
+            double gradient        = stimPlanModel->getUnderburdenGradient( curveProperty );
             underburdenTopValue    = values[lastIndex];
             underburdenBottomValue = underburdenTopValue + gradient * underburdenHeight;
         }
@@ -417,7 +417,7 @@ void RimFractureModelWellLogCalculator::addUnderburden( RiaDefines::CurvePropert
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimFractureModelWellLogCalculator::scaleByNetToGross( const RimFractureModel*    fractureModel,
+void RimStimPlanModelWellLogCalculator::scaleByNetToGross( const RimStimPlanModel*    stimPlanModel,
                                                            const std::vector<double>& netToGross,
                                                            std::vector<double>&       values )
 {
@@ -428,10 +428,10 @@ void RimFractureModelWellLogCalculator::scaleByNetToGross( const RimFractureMode
     }
 
     double cutoff = 1.0;
-    if ( fractureModel->fractureModelTemplate() && fractureModel->fractureModelTemplate()->nonNetLayers() &&
+    if ( stimPlanModel->stimPlanModelTemplate() && stimPlanModel->stimPlanModelTemplate()->nonNetLayers() &&
-         fractureModel->fractureModelTemplate()->nonNetLayers()->isChecked() )
+         stimPlanModel->stimPlanModelTemplate()->nonNetLayers()->isChecked() )
     {
-        cutoff = fractureModel->fractureModelTemplate()->nonNetLayers()->cutOff();
+        cutoff = stimPlanModel->stimPlanModelTemplate()->nonNetLayers()->cutOff();
     }
 
     for ( size_t i = 0; i < values.size(); i++ )

ApplicationCode/ProjectDataModel/StimPlanModel/RimStimPlanModelWellLogCalculator.h

@@ -17,10 +17,10 @@
 /////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
-#include "RimFractureModelCalculator.h"
+#include "RimStimPlanModelCalculator.h"
-#include "RimFractureModelPropertyCalculator.h"
+#include "RimStimPlanModelPropertyCalculator.h"
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include "cvfObject.h"
 
@@ -31,13 +31,13 @@ class RimEclipseInputPropertyCollection;
 class RimEclipseResultDefinition;
 class RigResultAccessor;
 
-class RimFractureModelWellLogCalculator : public RimFractureModelPropertyCalculator
+class RimStimPlanModelWellLogCalculator : public RimStimPlanModelPropertyCalculator
 {
 public:
-    RimFractureModelWellLogCalculator( RimFractureModelCalculator* fractureModelCalculator );
+    RimStimPlanModelWellLogCalculator( RimStimPlanModelCalculator* stimPlanModelCalculator );
 
     bool calculate( RiaDefines::CurveProperty curveProperty,
-                    const RimFractureModel*   fractureModel,
+                    const RimStimPlanModel*   stimPlanModel,
                     int                       timeStep,
                     std::vector<double>&      values,
                     std::vector<double>&      measuredDepthValues,
@@ -57,20 +57,20 @@ protected:
                                                            RimEclipseResultDefinition* eclipseResultDefinition ) const;
 
     void addOverburden( RiaDefines::CurveProperty curveProperty,
-                        const RimFractureModel*   fractureModel,
+                        const RimStimPlanModel*   stimPlanModel,
                         std::vector<double>&      tvDepthValues,
                         std::vector<double>&      measuredDepthValues,
                         std::vector<double>&      values ) const;
 
     void addUnderburden( RiaDefines::CurveProperty curveProperty,
-                         const RimFractureModel*   fractureModel,
+                         const RimStimPlanModel*   stimPlanModel,
                          std::vector<double>&      tvDepthValues,
                          std::vector<double>&      measuredDepthValues,
                          std::vector<double>&      values ) const;
 
-    static void scaleByNetToGross( const RimFractureModel*    fractureModel,
+    static void scaleByNetToGross( const RimStimPlanModel*    stimPlanModel,
                                    const std::vector<double>& netToGross,
                                    std::vector<double>&       values );
 
-    RimFractureModelCalculator* m_fractureModelCalculator;
+    RimStimPlanModelCalculator* m_stimPlanModelCalculator;
 };

ApplicationCode/ProjectDataModelCommands/CMakeLists_files.cmake

@@ -5,10 +5,10 @@ ${CMAKE_CURRENT_LIST_DIR}/RimcSummaryCase.h
 ${CMAKE_CURRENT_LIST_DIR}/RimcSummaryResampleData.h
 ${CMAKE_CURRENT_LIST_DIR}/RimcProject.h
 ${CMAKE_CURRENT_LIST_DIR}/RimcElasticProperties.h
-${CMAKE_CURRENT_LIST_DIR}/RimcFractureModelCollection.h
+${CMAKE_CURRENT_LIST_DIR}/RimcStimPlanModelCollection.h
-${CMAKE_CURRENT_LIST_DIR}/RimcFractureModelTemplateCollection.h
+${CMAKE_CURRENT_LIST_DIR}/RimcStimPlanModelTemplateCollection.h
-${CMAKE_CURRENT_LIST_DIR}/RimcFractureModelPlotCollection.h
+${CMAKE_CURRENT_LIST_DIR}/RimcStimPlanModelPlotCollection.h
-${CMAKE_CURRENT_LIST_DIR}/RimcFractureModel.h
+${CMAKE_CURRENT_LIST_DIR}/RimcStimPlanModel.h
 ${CMAKE_CURRENT_LIST_DIR}/RimcSurfaceCollection.h
 ${CMAKE_CURRENT_LIST_DIR}/RimcDataContainerDouble.h
 ${CMAKE_CURRENT_LIST_DIR}/RimcDataContainerString.h
@@ -21,10 +21,10 @@ ${CMAKE_CURRENT_LIST_DIR}/RimcSummaryCase.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimcSummaryResampleData.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimcProject.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimcElasticProperties.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimcFractureModelCollection.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimcStimPlanModelCollection.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimcFractureModelTemplateCollection.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimcStimPlanModelTemplateCollection.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimcFractureModelPlotCollection.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimcStimPlanModelPlotCollection.cpp
-${CMAKE_CURRENT_LIST_DIR}/RimcFractureModel.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimcStimPlanModel.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimcSurfaceCollection.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimcDataContainerDouble.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimcDataContainerString.cpp

ApplicationCode/ProjectDataModelCommands/RimcElasticProperties.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include "RimFractureModelCollection.h"
+#include "RimStimPlanModelCollection.h"
 
 #include "cafPdmField.h"
 #include "cafPdmObjectHandle.h"
@@ -28,8 +28,8 @@
 
 #include <QString>
 
-class RimFractureModelCollection;
+class RimStimPlanModelCollection;
-class RimFractureModelTemplate;
+class RimStimPlanModelTemplate;
 class RimWellPath;
 
 //==================================================================================================

ApplicationCode/ProjectDataModelCommands/RimcStimPlanModel.cpp

@@ -15,35 +15,35 @@
 //  for more details.
 //
 /////////////////////////////////////////////////////////////////////////////////
-#include "RimcFractureModel.h"
+#include "RimcStimPlanModel.h"
 
-#include "RifFractureModelExporter.h"
+#include "RifStimPlanModelExporter.h"
 
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
 
 #include "cafPdmAbstractFieldScriptingCapability.h"
 #include "cafPdmFieldScriptingCapability.h"
 
-CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimFractureModel, RimcFractureModel_exportToFile, "ExportToFile" );
+CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimStimPlanModel, RimcStimPlanModel_exportToFile, "ExportToFile" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimcFractureModel_exportToFile::RimcFractureModel_exportToFile( caf::PdmObjectHandle* self )
+RimcStimPlanModel_exportToFile::RimcStimPlanModel_exportToFile( caf::PdmObjectHandle* self )
     : caf::PdmObjectMethod( self )
 {
-    CAF_PDM_InitObject( "Export Fracture Model Plot", "", "", "Export Fracture Model Plot to File" );
+    CAF_PDM_InitObject( "Export StimPlan Model Plot", "", "", "Export StimPlan Model Plot to File" );
     CAF_PDM_InitScriptableFieldNoDefault( &m_directoryPath, "DirectoryPath", "", "", "", "Directory Path" );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-caf::PdmObjectHandle* RimcFractureModel_exportToFile::execute()
+caf::PdmObjectHandle* RimcStimPlanModel_exportToFile::execute()
 {
-    RimFractureModel* fractureModel = self<RimFractureModel>();
+    RimStimPlanModel* stimPlanModel = self<RimStimPlanModel>();
 
-    RifFractureModelExporter::writeToDirectory( fractureModel, fractureModel->useDetailedFluidLoss(), m_directoryPath() );
+    RifStimPlanModelExporter::writeToDirectory( stimPlanModel, stimPlanModel->useDetailedFluidLoss(), m_directoryPath() );
 
     return nullptr;
 }
@@ -51,7 +51,7 @@ caf::PdmObjectHandle* RimcFractureModel_exportToFile::execute()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimcFractureModel_exportToFile::resultIsPersistent() const
+bool RimcStimPlanModel_exportToFile::resultIsPersistent() const
 {
     return false;
 }
@@ -59,15 +59,15 @@ bool RimcFractureModel_exportToFile::resultIsPersistent() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::unique_ptr<caf::PdmObjectHandle> RimcFractureModel_exportToFile::defaultResult() const
+std::unique_ptr<caf::PdmObjectHandle> RimcStimPlanModel_exportToFile::defaultResult() const
 {
-    return std::unique_ptr<caf::PdmObjectHandle>( new RimFractureModel );
+    return std::unique_ptr<caf::PdmObjectHandle>( new RimStimPlanModel );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimcFractureModel_exportToFile::isNullptrValidResult() const
+bool RimcStimPlanModel_exportToFile::isNullptrValidResult() const
 {
     return true;
 }

ApplicationCode/ProjectDataModelCommands/RimcStimPlanModel.h

@@ -26,17 +26,17 @@
 
 #include <QString>
 
-class RimFractureModel;
+class RimStimPlanModel;
 
 //==================================================================================================
 ///
 //==================================================================================================
-class RimcFractureModel_exportToFile : public caf::PdmObjectMethod
+class RimcStimPlanModel_exportToFile : public caf::PdmObjectMethod
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimcFractureModel_exportToFile( caf::PdmObjectHandle* self );
+    RimcStimPlanModel_exportToFile( caf::PdmObjectHandle* self );
 
     caf::PdmObjectHandle*            execute() override;
     bool                             resultIsPersistent() const override;

ApplicationCode/ProjectDataModelCommands/RimcStimPlanModelCollection.cpp

@@ -15,70 +15,70 @@
 //  for more details.
 //
 /////////////////////////////////////////////////////////////////////////////////
-#include "RimcFractureModelCollection.h"
+#include "RimcStimPlanModelCollection.h"
 
 #include "RicElasticPropertiesImportTools.h"
 
-#include "FractureCommands/RicNewFractureModelFeature.h"
+#include "FractureCommands/RicNewStimPlanModelFeature.h"
 
 #include "RimEclipseCase.h"
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
-#include "RimFractureModelCollection.h"
+#include "RimStimPlanModelCollection.h"
-#include "RimFractureModelTemplate.h"
+#include "RimStimPlanModelTemplate.h"
 #include "RimWellPath.h"
 #include "RimWellPathCollection.h"
 
 #include "cafPdmAbstractFieldScriptingCapability.h"
 #include "cafPdmFieldScriptingCapability.h"
 
-CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimFractureModelCollection,
+CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimStimPlanModelCollection,
-                                   RimcFractureModelCollection_newFractureModel,
+                                   RimcStimPlanModelCollection_newStimPlanModel,
-                                   "NewFractureModel" );
+                                   "NewStimPlanModel" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimcFractureModelCollection_newFractureModel::RimcFractureModelCollection_newFractureModel( caf::PdmObjectHandle* self )
+RimcStimPlanModelCollection_newStimPlanModel::RimcStimPlanModelCollection_newStimPlanModel( caf::PdmObjectHandle* self )
     : caf::PdmObjectMethod( self )
 {
-    CAF_PDM_InitObject( "Create Fracture Model", "", "", "Create a new Fracture Model" );
+    CAF_PDM_InitObject( "Create StimPlan Model", "", "", "Create a new StimPlan Model" );
     CAF_PDM_InitScriptableFieldNoDefault( &m_eclipseCase, "EclipseCase", "", "", "", "Eclipse Case" );
     CAF_PDM_InitScriptableFieldNoDefault( &m_timeStep, "TimeStep", "", "", "", "Time Step" );
     CAF_PDM_InitScriptableFieldNoDefault( &m_wellPath, "WellPath", "", "", "", "Well Path" );
     CAF_PDM_InitScriptableFieldNoDefault( &m_md, "MeasuredDepth", "", "", "", "Measured Depth" );
-    CAF_PDM_InitScriptableFieldNoDefault( &m_fractureModelTemplate, "FractureModelTemplate", "", "", "", "Fracture Model Template" );
+    CAF_PDM_InitScriptableFieldNoDefault( &m_stimPlanModelTemplate, "StimPlanModelTemplate", "", "", "", "StimPlan Model Template" );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-caf::PdmObjectHandle* RimcFractureModelCollection_newFractureModel::execute()
+caf::PdmObjectHandle* RimcStimPlanModelCollection_newStimPlanModel::execute()
 {
-    RimFractureModel*           newFractureModel        = nullptr;
+    RimStimPlanModel*           newStimPlanModel        = nullptr;
-    RimFractureModelCollection* fractureModelCollection = self<RimFractureModelCollection>();
+    RimStimPlanModelCollection* stimPlanModelCollection = self<RimStimPlanModelCollection>();
     if ( m_wellPath && m_eclipseCase )
     {
         RimWellPathCollection* wellPathCollection = nullptr;
-        fractureModelCollection->firstAncestorOrThisOfTypeAsserted( wellPathCollection );
+        stimPlanModelCollection->firstAncestorOrThisOfTypeAsserted( wellPathCollection );
 
-        newFractureModel =
+        newStimPlanModel =
-            RicNewFractureModelFeature::addFractureModel( m_wellPath, wellPathCollection, m_eclipseCase, m_timeStep );
+            RicNewStimPlanModelFeature::addStimPlanModel( m_wellPath, wellPathCollection, m_eclipseCase, m_timeStep );
     }
 
-    if ( newFractureModel )
+    if ( newStimPlanModel )
     {
-        newFractureModel->setMD( m_md() );
+        newStimPlanModel->setMD( m_md() );
-        newFractureModel->setFractureModelTemplate( m_fractureModelTemplate() );
+        newStimPlanModel->setStimPlanModelTemplate( m_stimPlanModelTemplate() );
-        fractureModelCollection->updateAllRequiredEditors();
+        stimPlanModelCollection->updateAllRequiredEditors();
     }
 
-    return newFractureModel;
+    return newStimPlanModel;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimcFractureModelCollection_newFractureModel::resultIsPersistent() const
+bool RimcStimPlanModelCollection_newStimPlanModel::resultIsPersistent() const
 {
     return true;
 }
@@ -86,7 +86,7 @@ bool RimcFractureModelCollection_newFractureModel::resultIsPersistent() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::unique_ptr<caf::PdmObjectHandle> RimcFractureModelCollection_newFractureModel::defaultResult() const
+std::unique_ptr<caf::PdmObjectHandle> RimcStimPlanModelCollection_newStimPlanModel::defaultResult() const
 {
-    return std::unique_ptr<caf::PdmObjectHandle>( new RimFractureModel );
+    return std::unique_ptr<caf::PdmObjectHandle>( new RimStimPlanModel );
 }

ApplicationCode/ProjectDataModelCommands/RimcStimPlanModelCollection.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include "RimFractureModelCollection.h"
+#include "RimStimPlanModelCollection.h"
 
 #include "cafPdmField.h"
 #include "cafPdmObjectHandle.h"
@@ -28,20 +28,20 @@
 
 #include <QString>
 
-class RimFractureModelCollection;
+class RimStimPlanModelCollection;
-class RimFractureModelTemplate;
+class RimStimPlanModelTemplate;
 class RimWellPath;
 class RimEclipseCase;
 
 //==================================================================================================
 ///
 //==================================================================================================
-class RimcFractureModelCollection_newFractureModel : public caf::PdmObjectMethod
+class RimcStimPlanModelCollection_newStimPlanModel : public caf::PdmObjectMethod
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimcFractureModelCollection_newFractureModel( caf::PdmObjectHandle* self );
+    RimcStimPlanModelCollection_newStimPlanModel( caf::PdmObjectHandle* self );
 
     caf::PdmObjectHandle*            execute() override;
     bool                             resultIsPersistent() const override;
@@ -52,5 +52,5 @@ private:
     caf::PdmField<int>                          m_timeStep;
     caf::PdmPtrField<RimWellPath*>              m_wellPath;
     caf::PdmField<double>                       m_md;
-    caf::PdmPtrField<RimFractureModelTemplate*> m_fractureModelTemplate;
+    caf::PdmPtrField<RimStimPlanModelTemplate*> m_stimPlanModelTemplate;
 };

ApplicationCode/ProjectDataModelCommands/RimcStimPlanModelPlotCollection.cpp

@@ -15,53 +15,53 @@
 //  for more details.
 //
 /////////////////////////////////////////////////////////////////////////////////
-#include "RimcFractureModelPlotCollection.h"
+#include "RimcStimPlanModelPlotCollection.h"
 
-#include "CompletionCommands/RicNewFractureModelPlotFeature.h"
+#include "CompletionCommands/RicNewStimPlanModelPlotFeature.h"
 
 #include "RimEclipseCase.h"
-#include "RimFractureModel.h"
+#include "RimStimPlanModel.h"
-#include "RimFractureModelPlot.h"
+#include "RimStimPlanModelPlot.h"
-#include "RimFractureModelPlotCollection.h"
+#include "RimStimPlanModelPlotCollection.h"
 
 #include "cafPdmAbstractFieldScriptingCapability.h"
 #include "cafPdmFieldScriptingCapability.h"
 
-CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimFractureModelPlotCollection,
+CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimStimPlanModelPlotCollection,
-                                   RimcFractureModelPlotCollection_newFractureModelPlot,
+                                   RimcStimPlanModelPlotCollection_newStimPlanModelPlot,
-                                   "NewFractureModelPlot" );
+                                   "NewStimPlanModelPlot" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimcFractureModelPlotCollection_newFractureModelPlot::RimcFractureModelPlotCollection_newFractureModelPlot(
+RimcStimPlanModelPlotCollection_newStimPlanModelPlot::RimcStimPlanModelPlotCollection_newStimPlanModelPlot(
     caf::PdmObjectHandle* self )
     : caf::PdmObjectMethod( self )
 {
-    CAF_PDM_InitObject( "Create Fracture Model", "", "", "Create a new Fracture Model" );
+    CAF_PDM_InitObject( "Create StimPlan Model", "", "", "Create a new StimPlan Model" );
-    CAF_PDM_InitScriptableFieldNoDefault( &m_fractureModel, "FractureModel", "", "", "", "Fracture Model" );
+    CAF_PDM_InitScriptableFieldNoDefault( &m_stimPlanModel, "StimPlanModel", "", "", "", "StimPlan Model" );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-caf::PdmObjectHandle* RimcFractureModelPlotCollection_newFractureModelPlot::execute()
+caf::PdmObjectHandle* RimcStimPlanModelPlotCollection_newStimPlanModelPlot::execute()
 {
-    RimFractureModelPlot*           newFractureModelPlot        = nullptr;
+    RimStimPlanModelPlot*           newStimPlanModelPlot        = nullptr;
-    RimFractureModelPlotCollection* fractureModelPlotCollection = self<RimFractureModelPlotCollection>();
+    RimStimPlanModelPlotCollection* stimPlanModelPlotCollection = self<RimStimPlanModelPlotCollection>();
 
-    if ( m_fractureModel && fractureModelPlotCollection )
+    if ( m_stimPlanModel && stimPlanModelPlotCollection )
     {
-        newFractureModelPlot = RicNewFractureModelPlotFeature::createPlot( m_fractureModel );
+        newStimPlanModelPlot = RicNewStimPlanModelPlotFeature::createPlot( m_stimPlanModel );
     }
 
-    return newFractureModelPlot;
+    return newStimPlanModelPlot;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimcFractureModelPlotCollection_newFractureModelPlot::resultIsPersistent() const
+bool RimcStimPlanModelPlotCollection_newStimPlanModelPlot::resultIsPersistent() const
 {
     return true;
 }
@@ -69,7 +69,7 @@ bool RimcFractureModelPlotCollection_newFractureModelPlot::resultIsPersistent()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::unique_ptr<caf::PdmObjectHandle> RimcFractureModelPlotCollection_newFractureModelPlot::defaultResult() const
+std::unique_ptr<caf::PdmObjectHandle> RimcStimPlanModelPlotCollection_newStimPlanModelPlot::defaultResult() const
 {
-    return std::unique_ptr<caf::PdmObjectHandle>( new RimFractureModelPlot );
+    return std::unique_ptr<caf::PdmObjectHandle>( new RimStimPlanModelPlot );
 }

ApplicationCode/ProjectDataModelCommands/RimcStimPlanModelPlotCollection.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include "RimFractureModelPlotCollection.h"
+#include "RimStimPlanModelPlotCollection.h"
 
 #include "cafPdmField.h"
 #include "cafPdmObjectHandle.h"
@@ -26,22 +26,22 @@
 #include "cafPdmPtrArrayField.h"
 #include "cafPdmPtrField.h"
 
-class RimFractureModel;
+class RimStimPlanModel;
 
 //==================================================================================================
 ///
 //==================================================================================================
-class RimcFractureModelPlotCollection_newFractureModelPlot : public caf::PdmObjectMethod
+class RimcStimPlanModelPlotCollection_newStimPlanModelPlot : public caf::PdmObjectMethod
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimcFractureModelPlotCollection_newFractureModelPlot( caf::PdmObjectHandle* self );
+    RimcStimPlanModelPlotCollection_newStimPlanModelPlot( caf::PdmObjectHandle* self );
 
     caf::PdmObjectHandle*            execute() override;
     bool                             resultIsPersistent() const override;
     std::unique_ptr<PdmObjectHandle> defaultResult() const override;
 
 private:
-    caf::PdmPtrField<RimFractureModel*> m_fractureModel;
+    caf::PdmPtrField<RimStimPlanModel*> m_stimPlanModel;
 };

ApplicationCode/ProjectDataModelCommands/RimcStimPlanModelTemplateCollection.cpp

@@ -15,32 +15,32 @@
 //  for more details.
 //
 /////////////////////////////////////////////////////////////////////////////////
-#include "RimcFractureModelTemplateCollection.h"
+#include "RimcStimPlanModelTemplateCollection.h"
 
 #include "RicElasticPropertiesImportTools.h"
 #include "RicFaciesPropertiesImportTools.h"
 
 #include "FractureCommands/RicFractureNameGenerator.h"
-#include "FractureCommands/RicNewFractureModelFeature.h"
+#include "FractureCommands/RicNewStimPlanModelFeature.h"
 
-#include "RimFractureModelTemplate.h"
+#include "RimStimPlanModelTemplate.h"
-#include "RimFractureModelTemplateCollection.h"
+#include "RimStimPlanModelTemplateCollection.h"
 
 #include "cafPdmAbstractFieldScriptingCapability.h"
 #include "cafPdmFieldScriptingCapability.h"
 
-CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimFractureModelTemplateCollection,
+CAF_PDM_OBJECT_METHOD_SOURCE_INIT( RimStimPlanModelTemplateCollection,
-                                   RimcFractureModelTemplateCollection_newFractureModelTemplate,
+                                   RimcStimPlanModelTemplateCollection_newStimPlanModelTemplate,
-                                   "NewFractureModelTemplate" );
+                                   "NewStimPlanModelTemplate" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimcFractureModelTemplateCollection_newFractureModelTemplate::RimcFractureModelTemplateCollection_newFractureModelTemplate(
+RimcStimPlanModelTemplateCollection_newStimPlanModelTemplate::RimcStimPlanModelTemplateCollection_newStimPlanModelTemplate(
     caf::PdmObjectHandle* self )
     : caf::PdmObjectMethod( self )
 {
-    CAF_PDM_InitObject( "Create Fracture Model Template", "", "", "Create a new Fracture Model Template" );
+    CAF_PDM_InitObject( "Create StimPlan Model Template", "", "", "Create a new StimPlan Model Template" );
     CAF_PDM_InitScriptableFieldNoDefault( &m_faciesPropertiesFilePath,
                                           "FaciesPropertiesFilePath",
                                           "",
@@ -58,26 +58,26 @@ RimcFractureModelTemplateCollection_newFractureModelTemplate::RimcFractureModelT
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-caf::PdmObjectHandle* RimcFractureModelTemplateCollection_newFractureModelTemplate::execute()
+caf::PdmObjectHandle* RimcStimPlanModelTemplateCollection_newStimPlanModelTemplate::execute()
 {
-    RimFractureModelTemplate*           newFractureModelTemplate        = new RimFractureModelTemplate;
+    RimStimPlanModelTemplate*           newStimPlanModelTemplate        = new RimStimPlanModelTemplate;
-    RimFractureModelTemplateCollection* fractureModelTemplateCollection = self<RimFractureModelTemplateCollection>();
+    RimStimPlanModelTemplateCollection* stimPlanModelTemplateCollection = self<RimStimPlanModelTemplateCollection>();
-    newFractureModelTemplate->setName( RicFractureNameGenerator::nameForNewFractureModelTemplate() );
+    newStimPlanModelTemplate->setName( RicFractureNameGenerator::nameForNewStimPlanModelTemplate() );
-    fractureModelTemplateCollection->addFractureModelTemplate( newFractureModelTemplate );
+    stimPlanModelTemplateCollection->addStimPlanModelTemplate( newStimPlanModelTemplate );
 
     RicElasticPropertiesImportTools::importElasticPropertiesFromFile( m_elasticPropertiesFilePath,
-                                                                      newFractureModelTemplate );
+                                                                      newStimPlanModelTemplate );
     RicFaciesPropertiesImportTools::importFaciesPropertiesFromFile( m_faciesPropertiesFilePath,
-                                                                    newFractureModelTemplate,
+                                                                    newStimPlanModelTemplate,
                                                                     true );
-    fractureModelTemplateCollection->updateAllRequiredEditors();
+    stimPlanModelTemplateCollection->updateAllRequiredEditors();
-    return newFractureModelTemplate;
+    return newStimPlanModelTemplate;
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimcFractureModelTemplateCollection_newFractureModelTemplate::resultIsPersistent() const
+bool RimcStimPlanModelTemplateCollection_newStimPlanModelTemplate::resultIsPersistent() const
 {
     return true;
 }
@@ -85,7 +85,7 @@ bool RimcFractureModelTemplateCollection_newFractureModelTemplate::resultIsPersi
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::unique_ptr<caf::PdmObjectHandle> RimcFractureModelTemplateCollection_newFractureModelTemplate::defaultResult() const
+std::unique_ptr<caf::PdmObjectHandle> RimcStimPlanModelTemplateCollection_newStimPlanModelTemplate::defaultResult() const
 {
-    return std::unique_ptr<caf::PdmObjectHandle>( new RimFractureModelTemplate );
+    return std::unique_ptr<caf::PdmObjectHandle>( new RimStimPlanModelTemplate );
 }

ApplicationCode/ProjectDataModelCommands/RimcStimPlanModelTemplateCollection.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include "RimFractureModelTemplateCollection.h"
+#include "RimStimPlanModelTemplateCollection.h"
 
 #include "cafPdmField.h"
 #include "cafPdmObjectHandle.h"
@@ -28,17 +28,17 @@
 
 #include <QString>
 
-class RimFractureModelTemplateCollection;
+class RimStimPlanModelTemplateCollection;
 
 //==================================================================================================
 ///
 //==================================================================================================
-class RimcFractureModelTemplateCollection_newFractureModelTemplate : public caf::PdmObjectMethod
+class RimcStimPlanModelTemplateCollection_newStimPlanModelTemplate : public caf::PdmObjectMethod
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimcFractureModelTemplateCollection_newFractureModelTemplate( caf::PdmObjectHandle* self );
+    RimcStimPlanModelTemplateCollection_newStimPlanModelTemplate( caf::PdmObjectHandle* self );
 
     caf::PdmObjectHandle*            execute() override;
     bool                             resultIsPersistent() const override;

ApplicationCode/ReservoirDataModel/RigElasticProperties.h

@@ -18,7 +18,7 @@
 
 #pragma once
 
-#include "RiaFractureModelDefines.h"
+#include "RiaStimPlanModelDefines.h"
 
 #include <QString>
 

ApplicationCode/UnitTests/CMakeLists_files.cmake

@@ -73,7 +73,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RifElasticPropertiesReader-Test.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RiaStatisticsTools-Test.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RifStimPlanXmlReader-Test.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RigWellPathGeometryExporter-Test.cpp
-${CMAKE_CURRENT_LIST_DIR}/RifFractureModelDeviationFrkExporter-Test.cpp
+${CMAKE_CURRENT_LIST_DIR}/RifStimPlanModelDeviationFrkExporter-Test.cpp
 )
 
 if (RESINSIGHT_ENABLE_GRPC)

ApplicationCode/UnitTests/RifStimPlanModelDeviationFrkExporter-Test.cpp

@@ -1,11 +1,11 @@
 #include "gtest/gtest.h"
 
-#include "RifFractureModelDeviationFrkExporter.h"
+#include "RifStimPlanModelDeviationFrkExporter.h"
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-TEST( RifFractureModelDeviationFrkExporterTest, TvdFixup )
+TEST( RifStimPlanModelDeviationFrkExporterTest, TvdFixup )
 {
     std::vector<double> tvd =
         {475.722, 492.126, 508.53, 524.934, 541.338, 557.743, 574.147, 590.551, 606.955, 623.359, 639.764, 656.168, 672.572};
@@ -15,7 +15,7 @@ TEST( RifFractureModelDeviationFrkExporterTest, TvdFixup )
     std::vector<double> exportTvd;
     std::vector<double> exportMd;
 
-    RifFractureModelDeviationFrkExporter::fixupDepthValuesForExport( tvd, md, exportTvd, exportMd );
+    RifStimPlanModelDeviationFrkExporter::fixupDepthValuesForExport( tvd, md, exportTvd, exportMd );
 
     EXPECT_EQ( tvd.size(), exportTvd.size() );
     EXPECT_EQ( md.size(), exportMd.size() );

ApplicationCode/UserInterface/RiuViewerCommands.cpp

@@ -526,7 +526,7 @@ void RiuViewerCommands::displayContextMenu( QMouseEvent* event )
             menuBuilder << "RicNewValveAtMeasuredDepthFeature";
             menuBuilder << "RicNewFishbonesSubsAtMeasuredDepthFeature";
             menuBuilder << "RicNewWellPathFractureAtPosFeature";
-            menuBuilder << "RicNewWellPathFractureModelAtPosFeature";
+            menuBuilder << "RicNewWellPathStimPlanModelAtPosFeature";
             menuBuilder.addSeparator();
             menuBuilder << "RicNewWellPathAttributeFeature";
             menuBuilder << "RicWellPathImportCompletionsFileFeature";