Refactor: rename RimWellLogFile to RimWellLogLasFile

ApplicationLibCode/ProjectDataModel/WellLog/CMakeLists_files.cmake

@@ -16,11 +16,11 @@ set(SOURCE_GROUP_HEADER_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogPlotCollection.h
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogPlot.h
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogTrack.h
-    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogCurve.h
+    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogLasCurve.h
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogExtractionCurve.h
-    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFile.h
-    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileChannel.h
-    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileCurve.h
+    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogLasFile.h
+    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogChannel.h
+    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogLasFileCurve.h
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogRftCurve.h
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogWbsCurve.h
     ${CMAKE_CURRENT_LIST_DIR}/RimRftTools.h
@@ -35,14 +35,14 @@ set(SOURCE_GROUP_SOURCE_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogTrack.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogCurve.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogExtractionCurve.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFile.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogLasFile.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileChannel.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileCurve.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogLasFileCurve.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogRftCurve.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogWbsCurve.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogPlotNameConfig.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogExtractionCurveNameConfig.cpp
-    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileCurveNameConfig.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RimWellLogLasFileCurveNameConfig.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RimWellLogRftCurveNameConfig.cpp
     ${CMAKE_CURRENT_LIST_DIR}/Rim3dWellLogCurve.cpp
     ${CMAKE_CURRENT_LIST_DIR}/Rim3dWellLogFileCurve.cpp

ApplicationLibCode/ProjectDataModel/WellLog/Rim3dWellLogExtractionCurve.cpp

@@ -42,8 +42,8 @@
 #include "RimTools.h"
 #include "RimWellLogExtractionCurve.h"
 #include "RimWellLogExtractionCurveNameConfig.h"
-#include "RimWellLogFile.h"
 #include "RimWellLogFileChannel.h"
+#include "RimWellLogLasFile.h"
 #include "RimWellPath.h"
 
 #include "cafUtils.h"

ApplicationLibCode/ProjectDataModel/WellLog/Rim3dWellLogFileCurve.cpp

@@ -20,9 +20,9 @@
 
 #include "RigWellLogLasFile.h"
 
-#include "RimWellLogFile.h"
 #include "RimWellLogFileChannel.h"
-#include "RimWellLogFileCurveNameConfig.h"
+#include "RimWellLogLasFile.h"
+#include "RimWellLogLasFileCurveNameConfig.h"
 #include "RimWellPath.h"
 
 #include <QFileInfo>
@@ -46,7 +46,7 @@ Rim3dWellLogFileCurve::Rim3dWellLogFileCurve()
     CAF_PDM_InitFieldNoDefault( &m_wellLogFile, "WellLogFile", "Well Log File" );
 
     CAF_PDM_InitFieldNoDefault( &m_nameConfig, "NameConfig", "" );
-    m_nameConfig = new RimWellLogFileCurveNameConfig();
+    m_nameConfig = new RimWellLogLasFileCurveNameConfig();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -223,7 +223,7 @@ QList<caf::PdmOptionItemInfo> Rim3dWellLogFileCurve::calculateValueOptions( cons
 
         if ( wellPath && !wellPath->wellLogFiles().empty() )
         {
-            for ( RimWellLogFile* const wellLogFile : wellPath->wellLogFiles() )
+            for ( RimWellLogLasFile* const wellLogFile : wellPath->wellLogFiles() )
             {
                 QFileInfo fileInfo( wellLogFile->fileName() );
                 options.push_back( caf::PdmOptionItemInfo( fileInfo.baseName(), wellLogFile ) );

ApplicationLibCode/ProjectDataModel/WellLog/Rim3dWellLogFileCurve.h

@@ -24,8 +24,8 @@
 #include "cafPdmField.h"
 #include "cafPdmPtrField.h"
 
-class RimWellLogFile;
-class RimWellLogFileCurveNameConfig;
+class RimWellLogLasFile;
+class RimWellLogLasFileCurveNameConfig;
 
 //==================================================================================================
 ///
@@ -55,7 +55,7 @@ private:
     void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
 
 private:
-    caf::PdmPtrField<RimWellLogFile*>                  m_wellLogFile;
-    caf::PdmField<QString>                             m_wellLogChannelName;
-    caf::PdmChildField<RimWellLogFileCurveNameConfig*> m_nameConfig;
+    caf::PdmPtrField<RimWellLogLasFile*>                  m_wellLogFile;
+    caf::PdmField<QString>                                m_wellLogChannelName;
+    caf::PdmChildField<RimWellLogLasFileCurveNameConfig*> m_nameConfig;
 };

ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogCurveSet.cpp

@@ -39,9 +39,9 @@
 #include "RimSummaryCase.h"
 #include "RimSummaryCaseCollection.h"
 #include "RimWellLogCurve.h"
-#include "RimWellLogFile.h"
 #include "RimWellLogFileChannel.h"
-#include "RimWellLogFileCurve.h"
+#include "RimWellLogLasFile.h"
+#include "RimWellLogLasFileCurve.h"
 #include "RimWellLogPlot.h"
 #include "RimWellLogTrack.h"
 #include "RimWellPath.h"
@@ -360,8 +360,8 @@ void RimEnsembleWellLogCurveSet::updateAllCurves()
 
     if ( group )
     {
-        std::vector<RimWellLogFile*> allWellLogFiles = group->wellLogFiles();
-        std::vector<RimWellLogFile*> filteredCases   = filterEnsembleCases( allWellLogFiles );
+        std::vector<RimWellLogLasFile*> allWellLogFiles = group->wellLogFiles();
+        std::vector<RimWellLogLasFile*> filteredCases   = filterEnsembleCases( allWellLogFiles );
 
         m_isCurveSetFiltered = filteredCases.size() < allWellLogFiles.size();
 
@@ -640,7 +640,7 @@ void RimEnsembleWellLogCurveSet::updateFilterLegend()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimSummaryCase* RimEnsembleWellLogCurveSet::findMatchingSummaryCase( RimWellLogFileCurve* wellLogCurve ) const
+RimSummaryCase* RimEnsembleWellLogCurveSet::findMatchingSummaryCase( RimWellLogLasFileCurve* wellLogCurve ) const
 {
     RimSummaryCaseCollection*    summaryCaseCollection = m_ensembleCurveSet->summaryCaseCollection();
     std::vector<RimSummaryCase*> sumCases              = summaryCaseCollection->allSummaryCases();
@@ -674,7 +674,7 @@ void RimEnsembleWellLogCurveSet::updateCurveColors()
                 if ( dynamic_cast<RimEnsembleWellLogStatisticsCurve*>( curve.p() ) == nullptr )
                 {
                     // Look for a matching summary case
-                    RimSummaryCase* summaryCase = findMatchingSummaryCase( dynamic_cast<RimWellLogFileCurve*>( curve.p() ) );
+                    RimSummaryCase* summaryCase = findMatchingSummaryCase( dynamic_cast<RimWellLogLasFileCurve*>( curve.p() ) );
                     if ( summaryCase )
                     {
                         summaryCases.push_back( summaryCase );
@@ -736,7 +736,7 @@ void RimEnsembleWellLogCurveSet::updateCurveColors()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimEnsembleWellLogCurveSet::updateEnsembleCurves( const std::vector<RimWellLogFile*>& sumCases )
+void RimEnsembleWellLogCurveSet::updateEnsembleCurves( const std::vector<RimWellLogLasFile*>& sumCases )
 {
     auto plotTrack   = firstAncestorOrThisOfTypeAsserted<RimWellLogTrack>();
     auto wellLogPlot = firstAncestorOrThisOfTypeAsserted<RimWellLogPlot>();
@@ -767,7 +767,7 @@ void RimEnsembleWellLogCurveSet::updateEnsembleCurves( const std::vector<RimWell
 
             for ( auto& wellLogFile : sumCases )
             {
-                RimWellLogFileCurve* curve = new RimWellLogFileCurve;
+                RimWellLogLasFileCurve* curve = new RimWellLogLasFileCurve;
                 curve->setUiTreeHidden( true );
                 curve->setUiTreeChildrenHidden( true );
                 plotTrack->addCurve( curve );
@@ -838,13 +838,13 @@ void RimEnsembleWellLogCurveSet::setLogScaleFromSelectedResult( const QString re
 //--------------------------------------------------------------------------------------------------
 bool RimEnsembleWellLogCurveSet::updateStatistics()
 {
-    return updateStatistics( std::vector<RimWellLogFile*>() );
+    return updateStatistics( std::vector<RimWellLogLasFile*>() );
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimEnsembleWellLogCurveSet::updateStatistics( const std::vector<RimWellLogFile*>& sumCases )
+bool RimEnsembleWellLogCurveSet::updateStatistics( const std::vector<RimWellLogLasFile*>& sumCases )
 {
     RimEnsembleWellLogs* ensembleWellLogs   = m_ensembleWellLogs;
     QString              wellLogChannelName = m_wellLogChannelName();
@@ -855,7 +855,7 @@ bool RimEnsembleWellLogCurveSet::updateStatistics( const std::vector<RimWellLogF
         return false;
     }
     // Calculate
-    std::vector<RimWellLogFile*> wellLogFiles = sumCases;
+    std::vector<RimWellLogLasFile*> wellLogFiles = sumCases;
     if ( wellLogFiles.empty() )
     {
         if ( m_statistics->basedOnFilteredCases() )
@@ -871,7 +871,7 @@ bool RimEnsembleWellLogCurveSet::updateStatistics( const std::vector<RimWellLogF
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimEnsembleWellLogCurveSet::updateStatisticsCurves( const std::vector<RimWellLogFile*>& sumCases )
+void RimEnsembleWellLogCurveSet::updateStatisticsCurves( const std::vector<RimWellLogLasFile*>& sumCases )
 {
     deleteStatisticsCurves();
 
@@ -936,7 +936,7 @@ void RimEnsembleWellLogCurveSet::updateStatisticsCurves( const std::vector<RimWe
 //--------------------------------------------------------------------------------------------------
 void RimEnsembleWellLogCurveSet::updateStatisticsCurves()
 {
-    updateStatisticsCurves( std::vector<RimWellLogFile*>() );
+    updateStatisticsCurves( std::vector<RimWellLogLasFile*>() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -987,9 +987,9 @@ void RimEnsembleWellLogCurveSet::updateAllTextInPlot()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RimWellLogFile*> RimEnsembleWellLogCurveSet::filterEnsembleCases( const std::vector<RimWellLogFile*>& wellLogFiles )
+std::vector<RimWellLogLasFile*> RimEnsembleWellLogCurveSet::filterEnsembleCases( const std::vector<RimWellLogLasFile*>& wellLogFiles )
 {
-    std::vector<RimWellLogFile*> filteredCases;
+    std::vector<RimWellLogLasFile*> filteredCases;
 
     if ( m_ensembleCurveSet != nullptr && m_statistics->basedOnFilteredCases() )
     {
@@ -1020,7 +1020,7 @@ std::vector<RimWellLogFile*> RimEnsembleWellLogCurveSet::filterEnsembleCases( co
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimEnsembleWellLogCurveSet::isSameRealization( RimSummaryCase* summaryCase, RimWellLogFile* wellLogFile ) const
+bool RimEnsembleWellLogCurveSet::isSameRealization( RimSummaryCase* summaryCase, RimWellLogLasFile* wellLogFile ) const
 {
     QString wellLogFileName = wellLogFile->fileName();
 
@@ -1259,7 +1259,7 @@ bool RimEnsembleWellLogCurveSet::hasPropertyInFile( const QString& property ) co
     RimEnsembleWellLogs* group = m_ensembleWellLogs;
     if ( !group ) return false;
 
-    std::vector<RimWellLogFile*> allWellLogFiles = group->wellLogFiles();
+    std::vector<RimWellLogLasFile*> allWellLogFiles = group->wellLogFiles();
     for ( auto& wellLogFile : allWellLogFiles )
     {
         QString errorMessage;

ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogCurveSet.h

@@ -44,8 +44,8 @@ class RimEnsembleCurveFilterCollection;
 class RimEnsembleStatistics;
 class RimEnsembleStatisticsCase;
 class RimWellLogCurve;
-class RimWellLogFileCurve;
-class RimWellLogFile;
+class RimWellLogLasFileCurve;
+class RimWellLogLasFile;
 class RimPlotCurveAppearance;
 
 class RigWellPathFormations;
@@ -100,9 +100,9 @@ public:
 
     void updateAllTextInPlot();
 
-    std::vector<RimWellLogFile*> filterEnsembleCases( const std::vector<RimWellLogFile*>& sumCases );
-    void                         disableStatisticCurves();
-    bool                         isFiltered() const;
+    std::vector<RimWellLogLasFile*> filterEnsembleCases( const std::vector<RimWellLogLasFile*>& sumCases );
+    void                            disableStatisticCurves();
+    bool                            isFiltered() const;
 
     void updateEditors() override;
     void updateAllCurves() override;
@@ -130,9 +130,9 @@ public:
     bool hasPropertyInFile( const QString& property ) const;
 
 private:
-    void updateEnsembleCurves( const std::vector<RimWellLogFile*>& curves );
-    void updateStatisticsCurves( const std::vector<RimWellLogFile*>& curves );
-    bool updateStatistics( const std::vector<RimWellLogFile*>& sumCases );
+    void updateEnsembleCurves( const std::vector<RimWellLogLasFile*>& curves );
+    void updateStatisticsCurves( const std::vector<RimWellLogLasFile*>& curves );
+    bool updateStatistics( const std::vector<RimWellLogLasFile*>& sumCases );
 
     caf::PdmFieldHandle* userDescriptionField() override;
     caf::PdmFieldHandle* objectToggleField() override;
@@ -150,8 +150,8 @@ private:
 
     void updateCurveColors();
 
-    bool            isSameRealization( RimSummaryCase* summaryCase, RimWellLogFile* wellLogFile ) const;
-    RimSummaryCase* findMatchingSummaryCase( RimWellLogFileCurve* wellLogCurve ) const;
+    bool            isSameRealization( RimSummaryCase* summaryCase, RimWellLogLasFile* wellLogFile ) const;
+    RimSummaryCase* findMatchingSummaryCase( RimWellLogLasFileCurve* wellLogCurve ) const;
 
     void connectEnsembleCurveSetFilterSignals();
     void onFilterSourceChanged( const caf::SignalEmitter* emitter );

ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogStatistics.cpp

@@ -29,7 +29,7 @@
 #include "RigWellLogIndexDepthOffset.h"
 #include "RigWellLogLasFile.h"
 
-#include "RimWellLogFile.h"
+#include "RimWellLogLasFile.h"
 
 #include "cafAppEnum.h"
 
@@ -66,9 +66,9 @@ RimEnsembleWellLogStatistics::RimEnsembleWellLogStatistics()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimEnsembleWellLogStatistics::calculate( const std::vector<RimWellLogFile*>& wellLogFiles,
-                                              const QString&                      wellLogChannelName,
-                                              DepthEqualization                   depthEqualization )
+void RimEnsembleWellLogStatistics::calculate( const std::vector<RimWellLogLasFile*>& wellLogFiles,
+                                              const QString&                         wellLogChannelName,
+                                              DepthEqualization                      depthEqualization )
 {
     if ( depthEqualization == DepthEqualization::NONE )
     {
@@ -83,14 +83,14 @@ void RimEnsembleWellLogStatistics::calculate( const std::vector<RimWellLogFile*>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimEnsembleWellLogStatistics::calculate( const std::vector<RimWellLogFile*>& wellLogFiles, const QString& wellLogChannelName )
+void RimEnsembleWellLogStatistics::calculate( const std::vector<RimWellLogLasFile*>& wellLogFiles, const QString& wellLogChannelName )
 {
     RiaCurveMerger<double> curveMerger;
     RiaCurveMerger<double> tvdCurveMerger;
 
     RiaWeightedMeanCalculator<size_t> dataSetSizeCalc;
 
-    for ( RimWellLogFile* wellLogFile : wellLogFiles )
+    for ( RimWellLogLasFile* wellLogFile : wellLogFiles )
     {
         QString errorMessage;
         if ( wellLogFile->readFile( &errorMessage ) )
@@ -184,7 +184,7 @@ void RimEnsembleWellLogStatistics::calculate( const std::vector<RimWellLogFile*>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimEnsembleWellLogStatistics::calculateByKLayer( const std::vector<RimWellLogFile*>& wellLogFiles, const QString& wellLogChannelName )
+void RimEnsembleWellLogStatistics::calculateByKLayer( const std::vector<RimWellLogLasFile*>& wellLogFiles, const QString& wellLogChannelName )
 {
     std::shared_ptr<RigWellLogIndexDepthOffset> offsets = RimEnsembleWellLogStatistics::calculateIndexDepthOffset( wellLogFiles );
     if ( !offsets ) return;
@@ -192,7 +192,7 @@ void RimEnsembleWellLogStatistics::calculateByKLayer( const std::vector<RimWellL
     std::map<int, std::vector<double>> topValues;
     std::map<int, std::vector<double>> bottomValues;
 
-    for ( RimWellLogFile* wellLogFile : wellLogFiles )
+    for ( RimWellLogLasFile* wellLogFile : wellLogFiles )
     {
         QString errorMessage;
         if ( wellLogFile->readFile( &errorMessage ) )
@@ -280,7 +280,7 @@ void RimEnsembleWellLogStatistics::calculateByKLayer( const std::vector<RimWellL
 ///
 //--------------------------------------------------------------------------------------------------
 std::shared_ptr<RigWellLogIndexDepthOffset>
-    RimEnsembleWellLogStatistics::calculateIndexDepthOffset( const std::vector<RimWellLogFile*>& wellLogFiles )
+    RimEnsembleWellLogStatistics::calculateIndexDepthOffset( const std::vector<RimWellLogLasFile*>& wellLogFiles )
 {
     std::map<int, double> sumTopMds;
     std::map<int, double> sumTopTvds;
@@ -295,7 +295,7 @@ std::shared_ptr<RigWellLogIndexDepthOffset>
 
     std::vector<std::vector<double>> topValues;
 
-    for ( RimWellLogFile* wellLogFile : wellLogFiles )
+    for ( RimWellLogLasFile* wellLogFile : wellLogFiles )
     {
         QString errorMessage;
         if ( wellLogFile->readFile( &errorMessage ) )

ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogStatistics.h

@@ -25,7 +25,7 @@
 
 class QString;
 
-class RimWellLogFile;
+class RimWellLogLasFile;
 
 class RigWellLogIndexDepthOffset;
 
@@ -65,15 +65,15 @@ public:
     bool hasP90Data() const;
     bool hasMeanData() const;
 
-    void calculate( const std::vector<RimWellLogFile*>& sumCases, const QString& wellLogChannelName, DepthEqualization depthEqualization );
+    void calculate( const std::vector<RimWellLogLasFile*>& sumCases, const QString& wellLogChannelName, DepthEqualization depthEqualization );
 
-    static std::shared_ptr<RigWellLogIndexDepthOffset> calculateIndexDepthOffset( const std::vector<RimWellLogFile*>& wellLogFiles );
+    static std::shared_ptr<RigWellLogIndexDepthOffset> calculateIndexDepthOffset( const std::vector<RimWellLogLasFile*>& wellLogFiles );
 
     void clearData();
 
 private:
-    void calculate( const std::vector<RimWellLogFile*>& sumCases, const QString& wellLogChannelName );
-    void calculateByKLayer( const std::vector<RimWellLogFile*>& sumCases, const QString& wellLogChannelName );
+    void calculate( const std::vector<RimWellLogLasFile*>& sumCases, const QString& wellLogChannelName );
+    void calculateByKLayer( const std::vector<RimWellLogLasFile*>& sumCases, const QString& wellLogChannelName );
 
     QString                   m_logChannelUnitString;
     RiaDefines::DepthUnitType m_depthUnit;

ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogs.cpp

@@ -20,7 +20,7 @@
 
 #include "RiaLogging.h"
 
-#include "RimWellLogFile.h"
+#include "RimWellLogLasFile.h"
 
 #include "cafPdmFieldScriptingCapability.h"
 #include "cafPdmObjectScriptingCapability.h"
@@ -41,7 +41,7 @@ RimEnsembleWellLogs::RimEnsembleWellLogs()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimEnsembleWellLogs::removeWellLogFile( RimWellLogFile* summaryCase )
+void RimEnsembleWellLogs::removeWellLogFile( RimWellLogLasFile* summaryCase )
 {
     m_wellLogFiles.removeChild( summaryCase );
 }
@@ -49,7 +49,7 @@ void RimEnsembleWellLogs::removeWellLogFile( RimWellLogFile* summaryCase )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimEnsembleWellLogs::addWellLogFile( RimWellLogFile* summaryCase )
+void RimEnsembleWellLogs::addWellLogFile( RimWellLogLasFile* summaryCase )
 {
     m_wellLogFiles.push_back( summaryCase );
 }
@@ -57,7 +57,7 @@ void RimEnsembleWellLogs::addWellLogFile( RimWellLogFile* summaryCase )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RimWellLogFile*> RimEnsembleWellLogs::wellLogFiles() const
+std::vector<RimWellLogLasFile*> RimEnsembleWellLogs::wellLogFiles() const
 {
     return m_wellLogFiles().childrenByType();
 }

ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogs.h

@@ -22,7 +22,7 @@
 
 #include "cafPdmChildArrayField.h"
 
-class RimWellLogFile;
+class RimWellLogLasFile;
 
 //==================================================================================================
 ///
@@ -33,13 +33,13 @@ class RimEnsembleWellLogs : public RimNamedObject
 
 public:
     RimEnsembleWellLogs();
-    void removeWellLogFile( RimWellLogFile* wellLogFile );
-    void addWellLogFile( RimWellLogFile* wellLogFile );
+    void removeWellLogFile( RimWellLogLasFile* wellLogFile );
+    void addWellLogFile( RimWellLogLasFile* wellLogFile );
 
-    std::vector<RimWellLogFile*> wellLogFiles() const;
+    std::vector<RimWellLogLasFile*> wellLogFiles() const;
 
     void loadDataAndUpdate();
 
 private:
-    caf::PdmChildArrayField<RimWellLogFile*> m_wellLogFiles;
+    caf::PdmChildArrayField<RimWellLogLasFile*> m_wellLogFiles;
 };

ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogCurveCommonDataSource.cpp

@@ -34,7 +34,7 @@
 #include "RimTools.h"
 #include "RimWellFlowRateCurve.h"
 #include "RimWellLogExtractionCurve.h"
-#include "RimWellLogFileCurve.h"
+#include "RimWellLogLasFileCurve.h"
 #include "RimWellLogPlot.h"
 #include "RimWellLogPlotCollection.h"
 #include "RimWellLogRftCurve.h"
@@ -331,7 +331,7 @@ void RimWellLogCurveCommonDataSource::analyseCurvesAndTracks( const std::vector<
     for ( RimWellLogCurve* curve : curves )
     {
         auto* extractionCurve = dynamic_cast<RimWellLogExtractionCurve*>( curve );
-        auto* fileCurve       = dynamic_cast<RimWellLogFileCurve*>( curve );
+        auto* fileCurve       = dynamic_cast<RimWellLogLasFileCurve*>( curve );
         auto* flowRateCurve   = dynamic_cast<RimWellFlowRateCurve*>( curve );
         auto* rftCurve        = dynamic_cast<RimWellLogRftCurve*>( curve );
 
@@ -515,7 +515,7 @@ void RimWellLogCurveCommonDataSource::applyDataSourceChanges( const std::vector<
     std::set<RimWellLogPlot*> plots;
     for ( RimWellLogCurve* curve : curves )
     {
-        auto* fileCurve        = dynamic_cast<RimWellLogFileCurve*>( curve );
+        auto* fileCurve        = dynamic_cast<RimWellLogLasFileCurve*>( curve );
         auto* extractionCurve  = dynamic_cast<RimWellLogExtractionCurve*>( curve );
         auto* measurementCurve = dynamic_cast<RimWellMeasurementCurve*>( curve );
         auto* rftCurve         = dynamic_cast<RimWellLogRftCurve*>( curve );
@@ -527,7 +527,7 @@ void RimWellLogCurveCommonDataSource::applyDataSourceChanges( const std::vector<
                 fileCurve->setWellPath( wellPathToApply() );
                 if ( !fileCurve->wellLogChannelUiName().isEmpty() )
                 {
-                    RimWellLogFile* logFile = wellPathToApply()->firstWellLogFileMatchingChannelName( fileCurve->wellLogChannelUiName() );
+                    RimWellLogLasFile* logFile = wellPathToApply()->firstWellLogFileMatchingChannelName( fileCurve->wellLogChannelUiName() );
                     fileCurve->setWellLogFile( logFile );
                     auto parentPlot = fileCurve->firstAncestorOrThisOfTypeAsserted<RimWellLogPlot>();
                     plots.insert( parentPlot );

ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogExtractionCurve.cpp

@@ -53,8 +53,8 @@
 #include "RimWellBoreStabilityPlot.h"
 #include "RimWellLogCurve.h"
 #include "RimWellLogCurveCommonDataSource.h"
-#include "RimWellLogFile.h"
 #include "RimWellLogFileChannel.h"
+#include "RimWellLogLasFile.h"
 #include "RimWellLogPlot.h"
 #include "RimWellLogPlotCollection.h"
 #include "RimWellLogTrack.h"
@@ -872,7 +872,7 @@ void RimWellLogExtractionCurve::findAndLoadWbsParametersFromLasFiles( const RimW
 
         QString                                lasUnits;
         std::vector<std::pair<double, double>> lasFileValues =
-            RimWellLogFile::findMdAndChannelValuesForWellPath( wellPath, lasAddress, &lasUnits );
+            RimWellLogLasFile::findMdAndChannelValuesForWellPath( wellPath, lasAddress, &lasUnits );
         if ( !lasFileValues.empty() )
         {
             QString extractorUnits = RigGeoMechWellLogExtractor::parameterInputUnits( parameter );

ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFile.cpp

@@ -17,7 +17,7 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RimWellLogFile.h"
+#include "RimWellLogLasFile.h"
 
 #include "RiaGuiApplication.h"
 #include "RiaLogging.h"
@@ -42,27 +42,27 @@
 #include <QString>
 #include <QStringList>
 
-CAF_PDM_SOURCE_INIT( RimWellLogFile, "WellLogFile" );
+CAF_PDM_SOURCE_INIT( RimWellLogLasFile, "WellLogLasFile", "WellLogFile" );
 
 namespace caf
 {
 template <>
-void caf::AppEnum<RimWellLogFile::WellFlowCondition>::setUp()
+void caf::AppEnum<RimWellLogLasFile::WellFlowCondition>::setUp()
 {
-    addItem( RimWellLogFile::WELL_FLOW_COND_RESERVOIR, "RESERVOIR", "Reservoir Volumes" );
-    addItem( RimWellLogFile::WELL_FLOW_COND_STANDARD, "STANDARD", "Standard Volumes" );
+    addItem( RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR, "RESERVOIR", "Reservoir Volumes" );
+    addItem( RimWellLogLasFile::WELL_FLOW_COND_STANDARD, "STANDARD", "Standard Volumes" );
 }
 } // namespace caf
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-const QDateTime RimWellLogFile::DEFAULT_DATE_TIME = RiaQDateTimeTools::createUtcDateTime( QDate( 1900, 1, 1 ) );
+const QDateTime RimWellLogLasFile::DEFAULT_DATE_TIME = RiaQDateTimeTools::createUtcDateTime( QDate( 1900, 1, 1 ) );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellLogFile::RimWellLogFile()
+RimWellLogLasFile::RimWellLogLasFile()
 {
     CAF_PDM_InitObject( "Well LAS File Info", ":/LasFile16x16.png" );
 
@@ -85,7 +85,7 @@ RimWellLogFile::RimWellLogFile()
 
     CAF_PDM_InitField( &m_wellFlowCondition,
                        "WellFlowCondition",
-                       caf::AppEnum<RimWellLogFile::WellFlowCondition>( RimWellLogFile::WELL_FLOW_COND_STANDARD ),
+                       caf::AppEnum<RimWellLogLasFile::WellFlowCondition>( RimWellLogLasFile::WELL_FLOW_COND_STANDARD ),
                        "Well Flow Rates" );
 
     CAF_PDM_InitField( &m_invalidDateMessage, "InvalidDateMessage", QString( "Invalid or no date" ), "" );
@@ -99,7 +99,7 @@ RimWellLogFile::RimWellLogFile()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellLogFile::~RimWellLogFile()
+RimWellLogLasFile::~RimWellLogLasFile()
 {
     m_wellLogChannelNames.deleteChildren();
 }
@@ -107,17 +107,17 @@ RimWellLogFile::~RimWellLogFile()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellLogFile* RimWellLogFile::readWellLogFile( const QString& logFilePath, QString* errorMessage )
+RimWellLogLasFile* RimWellLogLasFile::readWellLogFile( const QString& logFilePath, QString* errorMessage )
 {
     CAF_ASSERT( errorMessage );
 
     QFileInfo fi( logFilePath );
 
-    RimWellLogFile* wellLogFile = nullptr;
+    RimWellLogLasFile* wellLogFile = nullptr;
 
     if ( fi.suffix().toUpper().compare( "LAS" ) == 0 )
     {
-        wellLogFile = new RimWellLogFile();
+        wellLogFile = new RimWellLogLasFile();
         wellLogFile->setFileName( logFilePath );
         if ( !wellLogFile->readFile( errorMessage ) )
         {
@@ -132,7 +132,7 @@ RimWellLogFile* RimWellLogFile::readWellLogFile( const QString& logFilePath, QSt
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFile::setFileName( const QString& fileName )
+void RimWellLogLasFile::setFileName( const QString& fileName )
 {
     m_fileName = fileName;
 }
@@ -140,7 +140,7 @@ void RimWellLogFile::setFileName( const QString& fileName )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimWellLogFile::readFile( QString* errorMessage )
+bool RimWellLogLasFile::readFile( QString* errorMessage )
 {
     if ( !m_wellLogDataFile.p() )
     {
@@ -197,7 +197,7 @@ bool RimWellLogFile::readFile( QString* errorMessage )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimWellLogFile::wellName() const
+QString RimWellLogLasFile::wellName() const
 {
     return m_wellName;
 }
@@ -205,7 +205,7 @@ QString RimWellLogFile::wellName() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QDateTime RimWellLogFile::date() const
+QDateTime RimWellLogLasFile::date() const
 {
     return m_date;
 }
@@ -213,7 +213,7 @@ QDateTime RimWellLogFile::date() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RimWellLogFileChannel*> RimWellLogFile::wellLogChannels() const
+std::vector<RimWellLogFileChannel*> RimWellLogLasFile::wellLogChannels() const
 {
     std::vector<RimWellLogFileChannel*> channels;
     for ( const auto& channel : m_wellLogChannelNames )
@@ -226,7 +226,7 @@ std::vector<RimWellLogFileChannel*> RimWellLogFile::wellLogChannels() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimWellLogFile::hasFlowData() const
+bool RimWellLogLasFile::hasFlowData() const
 {
     return RimWellPlotTools::hasFlowData( this );
 }
@@ -234,13 +234,13 @@ bool RimWellLogFile::hasFlowData() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<std::pair<double, double>> RimWellLogFile::findMdAndChannelValuesForWellPath( const RimWellPath* wellPath,
-                                                                                          const QString&     channelName,
-                                                                                          QString*           unitString /*=nullptr*/ )
+std::vector<std::pair<double, double>> RimWellLogLasFile::findMdAndChannelValuesForWellPath( const RimWellPath* wellPath,
+                                                                                             const QString&     channelName,
+                                                                                             QString*           unitString /*=nullptr*/ )
 {
     CVF_ASSERT( wellPath );
-    std::vector<RimWellLogFile*> wellLogFiles = wellPath->descendantsIncludingThisOfType<RimWellLogFile>();
-    for ( RimWellLogFile* wellLogFile : wellLogFiles )
+    std::vector<RimWellLogLasFile*> wellLogFiles = wellPath->descendantsIncludingThisOfType<RimWellLogLasFile>();
+    for ( RimWellLogLasFile* wellLogFile : wellLogFiles )
     {
         RigWellLogLasFile*  fileData      = wellLogFile->wellLogFileData();
         std::vector<double> channelValues = fileData->values( channelName );
@@ -266,7 +266,7 @@ std::vector<std::pair<double, double>> RimWellLogFile::findMdAndChannelValuesFor
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFile::setupBeforeSave()
+void RimWellLogLasFile::setupBeforeSave()
 {
     m_wellFlowCondition.xmlCapability()->setIOWritable( hasFlowData() );
 }
@@ -274,7 +274,7 @@ void RimWellLogFile::setupBeforeSave()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFile::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
+void RimWellLogLasFile::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
     uiOrdering.add( &m_fileName );
     uiOrdering.add( &m_date );
@@ -296,7 +296,7 @@ void RimWellLogFile::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering&
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFile::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
+void RimWellLogLasFile::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
 {
     if ( changedField == &m_date )
     {
@@ -308,7 +308,7 @@ void RimWellLogFile::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFile::defineEditorAttribute( const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute )
+void RimWellLogLasFile::defineEditorAttribute( const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute )
 {
     caf::PdmUiDateEditorAttribute* attrib = dynamic_cast<caf::PdmUiDateEditorAttribute*>( attribute );
     if ( attrib != nullptr )
@@ -320,7 +320,7 @@ void RimWellLogFile::defineEditorAttribute( const caf::PdmFieldHandle* field, QS
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimWellLogFile::isDateValid( const QDateTime dateTime )
+bool RimWellLogLasFile::isDateValid( const QDateTime dateTime )
 {
     return dateTime.isValid() && dateTime != DEFAULT_DATE_TIME;
 }

ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFile.h

@@ -36,17 +36,17 @@ class QString;
 ///
 ///
 //==================================================================================================
-class RimWellLogFile : public caf::PdmObject
+class RimWellLogLasFile : public caf::PdmObject
 {
     CAF_PDM_HEADER_INIT;
 
     const static QDateTime DEFAULT_DATE_TIME;
 
 public:
-    RimWellLogFile();
-    ~RimWellLogFile() override;
+    RimWellLogLasFile();
+    ~RimWellLogLasFile() override;
 
-    static RimWellLogFile* readWellLogFile( const QString& logFilePath, QString* errorMessage );
+    static RimWellLogLasFile* readWellLogFile( const QString& logFilePath, QString* errorMessage );
 
     void    setFileName( const QString& fileName );
     QString fileName() const { return m_fileName().path(); }
@@ -68,7 +68,7 @@ public:
         WELL_FLOW_COND_STANDARD
     };
 
-    RimWellLogFile::WellFlowCondition wellFlowRateCondition() const { return m_wellFlowCondition(); }
+    RimWellLogLasFile::WellFlowCondition wellFlowRateCondition() const { return m_wellFlowCondition(); }
 
     static std::vector<std::pair<double, double>>
         findMdAndChannelValuesForWellPath( const RimWellPath* wellPath, const QString& channelName, QString* unitString = nullptr );

ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFileCurve.cpp

@@ -17,7 +17,7 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RimWellLogFileCurve.h"
+#include "RimWellLogLasFileCurve.h"
 
 #include "RiaLogging.h"
 #include "RiaPreferences.h"
@@ -29,8 +29,8 @@
 
 #include "RimProject.h"
 #include "RimTools.h"
-#include "RimWellLogFile.h"
 #include "RimWellLogFileChannel.h"
+#include "RimWellLogLasFile.h"
 #include "RimWellLogPlot.h"
 #include "RimWellLogTrack.h"
 #include "RimWellPath.h"
@@ -45,12 +45,12 @@
 
 #include <QFileInfo>
 
-CAF_PDM_SOURCE_INIT( RimWellLogFileCurve, "WellLogFileCurve" );
+CAF_PDM_SOURCE_INIT( RimWellLogLasFileCurve, "WellLogLasFileCurve", "WellLogFileCurve" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellLogFileCurve::RimWellLogFileCurve()
+RimWellLogLasFileCurve::RimWellLogLasFileCurve()
 {
     CAF_PDM_InitObject( "Well Log File Curve", RimWellLogCurve::wellLogCurveIconName() );
 
@@ -67,14 +67,14 @@ RimWellLogFileCurve::RimWellLogFileCurve()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellLogFileCurve::~RimWellLogFileCurve()
+RimWellLogLasFileCurve::~RimWellLogLasFileCurve()
 {
 }
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFileCurve::onLoadDataAndUpdate( bool updateParentPlot )
+void RimWellLogLasFileCurve::onLoadDataAndUpdate( bool updateParentPlot )
 {
     RimPlotCurve::updateCurvePresentation( updateParentPlot );
 
@@ -212,9 +212,9 @@ void RimWellLogFileCurve::onLoadDataAndUpdate( bool updateParentPlot )
 ///
 //--------------------------------------------------------------------------------------------------
 std::pair<std::vector<double>, std::vector<double>>
-    RimWellLogFileCurve::adjustByIndexDepthOffsets( const std::vector<double>& measuredDepthValues,
-                                                    const std::vector<double>& values,
-                                                    const std::vector<double>& kIndexValues ) const
+    RimWellLogLasFileCurve::adjustByIndexDepthOffsets( const std::vector<double>& measuredDepthValues,
+                                                       const std::vector<double>& values,
+                                                       const std::vector<double>& kIndexValues ) const
 {
     CAF_ASSERT( values.size() == kIndexValues.size() );
 
@@ -262,7 +262,7 @@ std::pair<std::vector<double>, std::vector<double>>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFileCurve::setWellPath( RimWellPath* wellPath )
+void RimWellLogLasFileCurve::setWellPath( RimWellPath* wellPath )
 {
     m_wellPath = wellPath;
 }
@@ -270,7 +270,7 @@ void RimWellLogFileCurve::setWellPath( RimWellPath* wellPath )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellPath* RimWellLogFileCurve::wellPath() const
+RimWellPath* RimWellLogLasFileCurve::wellPath() const
 {
     return m_wellPath;
 }
@@ -278,7 +278,7 @@ RimWellPath* RimWellLogFileCurve::wellPath() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFileCurve::setWellLogChannelName( const QString& name )
+void RimWellLogLasFileCurve::setWellLogChannelName( const QString& name )
 {
     m_wellLogChannelName = name;
 }
@@ -286,7 +286,7 @@ void RimWellLogFileCurve::setWellLogChannelName( const QString& name )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFileCurve::setWellLogFile( RimWellLogFile* wellLogFile )
+void RimWellLogLasFileCurve::setWellLogFile( RimWellLogLasFile* wellLogFile )
 {
     m_wellLogFile = wellLogFile;
 }
@@ -294,7 +294,7 @@ void RimWellLogFileCurve::setWellLogFile( RimWellLogFile* wellLogFile )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFileCurve::setIndexDepthOffsets( std::shared_ptr<RigWellLogIndexDepthOffset> depthOffsets )
+void RimWellLogLasFileCurve::setIndexDepthOffsets( std::shared_ptr<RigWellLogIndexDepthOffset> depthOffsets )
 {
     m_indexDepthOffsets = depthOffsets;
 }
@@ -302,7 +302,7 @@ void RimWellLogFileCurve::setIndexDepthOffsets( std::shared_ptr<RigWellLogIndexD
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFileCurve::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
+void RimWellLogLasFileCurve::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
 {
     RimWellLogCurve::fieldChangedByUi( changedField, oldValue, newValue );
 
@@ -324,7 +324,7 @@ void RimWellLogFileCurve::fieldChangedByUi( const caf::PdmFieldHandle* changedFi
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFileCurve::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
+void RimWellLogLasFileCurve::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
     RimPlotCurve::updateFieldUiState();
 
@@ -339,7 +339,7 @@ void RimWellLogFileCurve::defineUiOrdering( QString uiConfigName, caf::PdmUiOrde
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFileCurve::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/ )
+void RimWellLogLasFileCurve::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/ )
 {
     uiTreeOrdering.skipRemainingChildren( true );
 }
@@ -347,7 +347,7 @@ void RimWellLogFileCurve::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOr
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QList<caf::PdmOptionItemInfo> RimWellLogFileCurve::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions )
+QList<caf::PdmOptionItemInfo> RimWellLogLasFileCurve::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions )
 {
     QList<caf::PdmOptionItemInfo> options;
 
@@ -401,7 +401,7 @@ QList<caf::PdmOptionItemInfo> RimWellLogFileCurve::calculateValueOptions( const
     {
         if ( m_wellPath() && !m_wellPath->wellLogFiles().empty() )
         {
-            for ( RimWellLogFile* const wellLogFile : m_wellPath->wellLogFiles() )
+            for ( RimWellLogLasFile* const wellLogFile : m_wellPath->wellLogFiles() )
             {
                 QFileInfo fileInfo( wellLogFile->fileName() );
                 options.push_back( caf::PdmOptionItemInfo( fileInfo.baseName(), wellLogFile ) );
@@ -415,7 +415,7 @@ QList<caf::PdmOptionItemInfo> RimWellLogFileCurve::calculateValueOptions( const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFileCurve::initAfterRead()
+void RimWellLogLasFileCurve::initAfterRead()
 {
     RimWellLogCurve::initAfterRead();
 
@@ -430,7 +430,7 @@ void RimWellLogFileCurve::initAfterRead()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RimWellLogFileCurve::isRftPlotChild() const
+bool RimWellLogLasFileCurve::isRftPlotChild() const
 {
     RimWellRftPlot* rftPlot = firstAncestorOrThisOfType<RimWellRftPlot>();
     return rftPlot != nullptr;
@@ -439,7 +439,7 @@ bool RimWellLogFileCurve::isRftPlotChild() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimWellLogFileCurve::createCurveAutoName()
+QString RimWellLogLasFileCurve::createCurveAutoName()
 {
     QStringList name;
     QString     unit;
@@ -487,7 +487,7 @@ QString RimWellLogFileCurve::createCurveAutoName()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimWellLogFileCurve::wellLogChannelUiName() const
+QString RimWellLogLasFileCurve::wellLogChannelUiName() const
 {
     return m_wellLogChannelName;
 }
@@ -495,7 +495,7 @@ QString RimWellLogFileCurve::wellLogChannelUiName() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimWellLogFileCurve::wellLogChannelUnits() const
+QString RimWellLogLasFileCurve::wellLogChannelUnits() const
 {
     if ( m_wellLogFile && m_wellLogFile->wellLogFileData() )
     {
@@ -507,7 +507,7 @@ QString RimWellLogFileCurve::wellLogChannelUnits() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellLogFile* RimWellLogFileCurve::wellLogFile() const
+RimWellLogLasFile* RimWellLogLasFileCurve::wellLogFile() const
 {
     return m_wellLogFile();
 }
@@ -515,7 +515,7 @@ RimWellLogFile* RimWellLogFileCurve::wellLogFile() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RimWellLogFileCurve::wellName() const
+QString RimWellLogLasFileCurve::wellName() const
 {
     if ( m_wellPath )
     {

ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFileCurve.h

@@ -28,25 +28,25 @@
 
 class RimWellPath;
 class RimWellLogFileChannel;
-class RimWellLogFile;
+class RimWellLogLasFile;
 class RigWellLogIndexDepthOffset;
 
 //==================================================================================================
 ///
 ///
 //==================================================================================================
-class RimWellLogFileCurve : public RimWellLogCurve
+class RimWellLogLasFileCurve : public RimWellLogCurve
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimWellLogFileCurve();
-    ~RimWellLogFileCurve() override;
+    RimWellLogLasFileCurve();
+    ~RimWellLogLasFileCurve() override;
 
     void         setWellPath( RimWellPath* wellPath );
     RimWellPath* wellPath() const;
     void         setWellLogChannelName( const QString& name );
-    void         setWellLogFile( RimWellLogFile* wellLogFile );
+    void         setWellLogFile( RimWellLogLasFile* wellLogFile );
     void         setIndexDepthOffsets( std::shared_ptr<RigWellLogIndexDepthOffset> depthOffsets );
 
     // Overrides from RimWellLogPlotCurve
@@ -54,7 +54,7 @@ public:
     QString wellLogChannelUiName() const override;
     QString wellLogChannelUnits() const override;
 
-    RimWellLogFile* wellLogFile() const;
+    RimWellLogLasFile* wellLogFile() const;
 
 protected:
     // Overrides from RimWellLogPlotCurve
@@ -75,10 +75,10 @@ protected:
                                                                                    const std::vector<double>& kIndexValues ) const;
 
 protected:
-    caf::PdmPtrField<RimWellPath*>    m_wellPath;
-    caf::PdmPtrField<RimWellLogFile*> m_wellLogFile;
-    caf::PdmField<QString>            m_wellLogChannelName;
-    caf::PdmField<QString>            m_wellLogChannnelUnit;
+    caf::PdmPtrField<RimWellPath*>       m_wellPath;
+    caf::PdmPtrField<RimWellLogLasFile*> m_wellLogFile;
+    caf::PdmField<QString>               m_wellLogChannelName;
+    caf::PdmField<QString>               m_wellLogChannnelUnit;
 
     std::shared_ptr<RigWellLogIndexDepthOffset> m_indexDepthOffsets;
 };

ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFileCurveNameConfig.cpp

@@ -16,19 +16,19 @@
 //
 /////////////////////////////////////////////////////////////////////////////////
 
-#include "RimWellLogFileCurveNameConfig.h"
+#include "RimWellLogLasFileCurveNameConfig.h"
 
 //==================================================================================================
 ///
 ///
 //==================================================================================================
 
-CAF_PDM_SOURCE_INIT( RimWellLogFileCurveNameConfig, "RimWellLogFileCurveNameConfig" );
+CAF_PDM_SOURCE_INIT( RimWellLogLasFileCurveNameConfig, "RimWellLogLasFileCurveNameConfig", "RimWellLogFileCurveNameConfig" );
 
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimWellLogFileCurveNameConfig::RimWellLogFileCurveNameConfig()
+RimWellLogLasFileCurveNameConfig::RimWellLogLasFileCurveNameConfig()
     : RimNameConfig( "Las Curve" )
 {
     CAF_PDM_InitObject( "Well Log File Curve Name Generator" );
@@ -37,6 +37,6 @@ RimWellLogFileCurveNameConfig::RimWellLogFileCurveNameConfig()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogFileCurveNameConfig::doEnableAllAutoNameTags( bool enable )
+void RimWellLogLasFileCurveNameConfig::doEnableAllAutoNameTags( bool enable )
 {
 }

ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFileCurveNameConfig.h

@@ -24,12 +24,12 @@
 ///
 ///
 //==================================================================================================
-class RimWellLogFileCurveNameConfig : public RimNameConfig
+class RimWellLogLasFileCurveNameConfig : public RimNameConfig
 {
     CAF_PDM_HEADER_INIT;
 
 public:
-    RimWellLogFileCurveNameConfig();
+    RimWellLogLasFileCurveNameConfig();
 
 private:
     void doEnableAllAutoNameTags( bool enable ) override;