OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Refactor: rename RimWellLogFile to RimWellLogLasFile

Browse Source
This commit is contained in:
Kristian Bendiksen 2023-10-02 12:39:44 +02:00
parent d177491843
commit 8df4dd42eb
63 changed files with 353 additions and 349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ApplicationLibCode/Application/RiaApplication.cpp
View File

@ -83,7 +83,7 @@
#include "RimTextAnnotationInView.h"
#include "RimViewLinker.h"
#include "RimViewLinkerCollection.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"
#include "RimWellPathFracture.h"
@ -986,8 +986,8 @@ void RiaApplication::addWellPathFormationsToModel( QList<QString> wellPathFormat
//--------------------------------------------------------------------------------------------------
/// Add a list of well log file paths (LAS files) to the well path collection
//--------------------------------------------------------------------------------------------------
std::vector<RimWellLogFile*> RiaApplication::addWellLogsToModel( const QList<QString>& wellLogFilePaths,
gsl::not_null<QStringList*> errorMessages )
std::vector<RimWellLogLasFile*> RiaApplication::addWellLogsToModel( const QList<QString>& wellLogFilePaths,
gsl::not_null<QStringList*> errorMessages )
{
if ( m_project == nullptr || m_project->oilFields.empty() ) return {};
@ -1001,7 +1001,7 @@ std::vector<RimWellLogFile*> RiaApplication::addWellLogsToModel( const QList<QSt
m_project->updateConnectedEditors();
}
std::vector<RimWellLogFile*> wellLogFiles = oilField->wellPathCollection->addWellLogs( wellLogFilePaths, errorMessages );
std::vector<RimWellLogLasFile*> wellLogFiles = oilField->wellPathCollection->addWellLogs( wellLogFilePaths, errorMessages );
oilField->wellPathCollection->updateConnectedEditors();

8
ApplicationLibCode/Application/RiaApplication.h
View File

@ -61,7 +61,7 @@ class RimProject;
class RimSummaryPlot;
class Rim3dView;
class RimViewWindow;
class RimWellLogFile;
class RimWellLogLasFile;
class RimWellLogPlot;
class RimWellAllocationPlot;
@ -147,9 +147,9 @@ public:
bool openOdbCaseFromFile( const QString& fileName, bool applyTimeStepFilter = false );
std::vector<RimWellPath*> addWellPathsToModel( QList<QString> wellPathFilePaths, gsl::not_null<QStringList*> errorMessages );
void addWellPathFormationsToModel( QList<QString> wellPathFilePaths );
std::vector<RimWellLogFile*> addWellLogsToModel( const QList<QString>& wellLogFilePaths, gsl::not_null<QStringList*> errorMessages );
std::vector<RimWellPath*> addWellPathsToModel( QList<QString> wellPathFilePaths, gsl::not_null<QStringList*> errorMessages );
void addWellPathFormationsToModel( QList<QString> wellPathFilePaths );
std::vector<RimWellLogLasFile*> addWellLogsToModel( const QList<QString>& wellLogFilePaths, gsl::not_null<QStringList*> errorMessages );
QString scriptDirectories() const;
QString scriptEditorPath() const;

2
ApplicationLibCode/Application/RiaGuiApplication.cpp
View File

@ -84,7 +84,7 @@
#include "RimTools.h"
#include "RimViewLinker.h"
#include "RimViewLinkerCollection.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogPlot.h"
#include "RimWellLogPlotCollection.h"
#include "RimWellPathCollection.h"

6
ApplicationLibCode/CommandFileInterface/RicfImportWellLogFiles.cpp
View File

@ -20,7 +20,7 @@
#include "WellLogCommands/RicWellLogsImportFileFeature.h"
#include "RiaApplication.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "cafPdmFieldScriptingCapability.h"
@ -100,12 +100,12 @@ caf::PdmScriptResponse RicfImportWellLogFiles::execute()
if ( !wellLogFilePaths.empty() )
{
std::vector<RimWellLogFile*> importedWellLogFiles =
std::vector<RimWellLogLasFile*> importedWellLogFiles =
RicWellLogsImportFileFeature::importWellLogFiles( wellLogFilePaths, &warningMessages );
if ( !importedWellLogFiles.empty() )
{
RicfImportWellLogFilesResult* result = new RicfImportWellLogFilesResult;
for ( RimWellLogFile* wellLogFile : importedWellLogFiles )
for ( RimWellLogLasFile* wellLogFile : importedWellLogFiles )
{
result->wellPathNames.v().push_back( wellLogFile->wellName() );
}

8
ApplicationLibCode/Commands/ExportCommands/RicCreateDepthAdjustedLasFilesFeature.cpp
View File

@ -32,7 +32,7 @@
#include "RimMainPlotCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogPlotCollection.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"
@ -66,7 +66,7 @@ void RicCreateDepthAdjustedLasFilesFeature::onActionTriggered( bool isChecked )
{
RimCase* selectedCase = featureUi.selectedCase();
RimWellPath* sourceWell = featureUi.sourceWell();
RimWellLogFile* soureWellLogFile = featureUi.wellLogFile();
RimWellLogLasFile* soureWellLogFile = featureUi.wellLogFile();
std::vector<RimWellPath*> destinationWells = featureUi.destinationWells().ptrReferencedObjectsByType();
std::vector<QString> selectedResultProperties = featureUi.selectedResultProperties();
QString exportFolder = featureUi.exportFolder();
@ -115,7 +115,7 @@ void RicCreateDepthAdjustedLasFilesFeature::setupActionLook( QAction* actionToSe
//--------------------------------------------------------------------------------------------------
void RicCreateDepthAdjustedLasFilesFeature::createDepthAdjustedWellLogFileFromEclipseCase( RimEclipseCase* eclipseCase,
RimWellPath* sourceWell,
RimWellLogFile* soureWellLogFile,
RimWellLogLasFile* soureWellLogFile,
const std::vector<RimWellPath*> destinationWells,
const std::vector<QString>& selectedResultProperties,
const QString& exportFolder )
@ -144,7 +144,7 @@ void RicCreateDepthAdjustedLasFilesFeature::createDepthAdjustedWellLogFileFromEc
//--------------------------------------------------------------------------------------------------
void RicCreateDepthAdjustedLasFilesFeature::createDepthAdjustedWellLogFileFromGeoMechCase( RimGeoMechCase* geoMechCase,
RimWellPath* sourceWell,
RimWellLogFile* soureWellLogFile,
RimWellLogLasFile* soureWellLogFile,
const std::vector<RimWellPath*> destinationWells,
const std::vector<QString>& selectedResultProperties,
const QString& exportFolder )

6
ApplicationLibCode/Commands/ExportCommands/RicCreateDepthAdjustedLasFilesFeature.h
View File

@ -23,7 +23,7 @@
class RimEclipseCase;
class RimGeoMechCase;
class RimWellPath;
class RimWellLogFile;
class RimWellLogLasFile;
//==================================================================================================
///
@ -42,14 +42,14 @@ protected:
private:
void createDepthAdjustedWellLogFileFromEclipseCase( RimEclipseCase* eclipseCase,
RimWellPath* sourceWell,
RimWellLogFile* soureWellLogFile,
RimWellLogLasFile* soureWellLogFile,
const std::vector<RimWellPath*> destinationWells,
const std::vector<QString>& selectedResultProperties,
const QString& exportFolder );
void createDepthAdjustedWellLogFileFromGeoMechCase( RimGeoMechCase* geoMechCase,
RimWellPath* sourceWell,
RimWellLogFile* soureWellLogFile,
RimWellLogLasFile* soureWellLogFile,
const std::vector<RimWellPath*> destinationWells,
const std::vector<QString>& selectedResultProperties,
const QString& exportFolder );

4
ApplicationLibCode/Commands/ExportCommands/RicCreateDepthAdjustedLasFilesImpl.cpp
View File

@ -33,7 +33,7 @@
#include "RimEclipseCase.h"
#include "RimGeoMechCase.h"
#include "RimMainPlotCollection.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogPlotCollection.h"
#include "RimWellPath.h"
@ -114,7 +114,7 @@ LasDepthValueAndIndexPerKLayer
//--------------------------------------------------------------------------------------------------
void RicCreateDepthAdjustedLasFilesImpl::createDestinationWellsLasFiles( RimCase* selectedCase,
RimWellPath* sourceWell,
RimWellLogFile* soureWellLogFile,
RimWellLogLasFile* soureWellLogFile,
const std::vector<RimWellPath*> destinationWells,
const std::vector<QString>& selectedResultProperties,
const QString& exportFolder,

4
ApplicationLibCode/Commands/ExportCommands/RicCreateDepthAdjustedLasFilesImpl.h
View File

@ -29,7 +29,7 @@ class RigWellLogLasFile;
class RimCase;
class RimEclipseCase;
class RimWellPath;
class RimWellLogFile;
class RimWellLogLasFile;
//==================================================================================================
/// Object to hold Depth value and its original index in a LAS file vector categorized by K-layer.
@ -65,7 +65,7 @@ cvf::ref<RigResultAccessor> createIndexKResultAccessor( RimEclipseCase* selected
void createDestinationWellsLasFiles( RimCase* selectedCase,
RimWellPath* sourceWell,
RimWellLogFile* soureWellLogFile,
RimWellLogLasFile* soureWellLogFile,
const std::vector<RimWellPath*> destinationWells,
const std::vector<QString>& selectedResultProperties,
const QString& exportFolder,

2
ApplicationLibCode/Commands/ExportCommands/RicCreateDepthAdjustedLasFilesUi.cpp
View File

@ -24,8 +24,8 @@
#include "RimOilField.h"
#include "RimProject.h"
#include "RimTools.h"
#include "RimWellLogFile.h"
#include "RimWellLogFileChannel.h"
#include "RimWellLogLasFile.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"

14
ApplicationLibCode/Commands/ExportCommands/RicCreateDepthAdjustedLasFilesUi.h
View File

@ -32,7 +32,7 @@
class RimCase;
class RimWellPath;
class RimWellLogFile;
class RimWellLogLasFile;
//==================================================================================================
///
@ -54,12 +54,12 @@ public:
QString invalidSelectionsLogString() const;
public:
caf::PdmField<QString> exportFolder;
caf::PdmPtrField<RimCase*> selectedCase;
caf::PdmPtrField<RimWellPath*> sourceWell;
caf::PdmPtrField<RimWellLogFile*> wellLogFile;
caf::PdmField<std::vector<QString>> selectedResultProperties;
caf::PdmPtrArrayField<RimWellPath*> destinationWells;
caf::PdmField<QString> exportFolder;
caf::PdmPtrField<RimCase*> selectedCase;
caf::PdmPtrField<RimWellPath*> sourceWell;
caf::PdmPtrField<RimWellLogLasFile*> wellLogFile;
caf::PdmField<std::vector<QString>> selectedResultProperties;
caf::PdmPtrArrayField<RimWellPath*> destinationWells;
protected:
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;

8
ApplicationLibCode/Commands/RicImportEnsembleWellLogsFeature.cpp
View File

@ -26,7 +26,7 @@
#include "RimEnsembleWellLogsCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RicRecursiveFileSearchDialog.h"
#include "WellLogCommands/RicWellLogsImportFileFeature.h"
@ -85,11 +85,11 @@ RimEnsembleWellLogs*
{
if ( fileNames.isEmpty() ) return nullptr;
std::vector<RimWellLogFile*> cases;
std::vector<RimWellLogLasFile*> cases;
for ( QString fileNames : fileNames )
{
QString errorMessage;
RimWellLogFile* logFileInfo = RimWellLogFile::readWellLogFile( fileNames, &errorMessage );
QString errorMessage;
RimWellLogLasFile* logFileInfo = RimWellLogLasFile::readWellLogFile( fileNames, &errorMessage );
cases.push_back( logFileInfo );
if ( !errorMessage.isEmpty() )
{

14
ApplicationLibCode/Commands/RicWellLogTools.cpp
View File

@ -33,9 +33,9 @@
#include "RimWellLogCalculatedCurve.h"
#include "RimWellLogCurveCommonDataSource.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellLogFile.h"
#include "RimWellLogFileChannel.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogLasFileCurve.h"
#include "RimWellLogRftCurve.h"
#include "RimWellLogTrack.h"
#include "RimWellLogWbsCurve.h"
@ -140,10 +140,10 @@ void RicWellLogTools::addWellLogChannelsToPlotTrack( RimWellLogTrack* plotTrack,
{
for ( size_t cIdx = 0; cIdx < wellLogFileChannels.size(); cIdx++ )
{
RimWellLogFileCurve* plotCurve = RicWellLogTools::addFileCurve( plotTrack );
RimWellLogLasFileCurve* plotCurve = RicWellLogTools::addFileCurve( plotTrack );
RimWellPath* wellPath = wellLogFileChannels[cIdx]->firstAncestorOrThisOfType<RimWellPath>();
RimWellLogFile* wellLogFile = wellLogFileChannels[cIdx]->firstAncestorOrThisOfType<RimWellLogFile>();
RimWellPath* wellPath = wellLogFileChannels[cIdx]->firstAncestorOrThisOfType<RimWellPath>();
RimWellLogLasFile* wellLogFile = wellLogFileChannels[cIdx]->firstAncestorOrThisOfType<RimWellLogLasFile>();
if ( wellPath )
{
@ -406,11 +406,11 @@ RimWellLogRftCurve* RicWellLogTools::addRftCurve( RimWellLogTrack* plotTrack, co
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellLogFileCurve* RicWellLogTools::addFileCurve( RimWellLogTrack* plotTrack, bool showPlotWindow )
RimWellLogLasFileCurve* RicWellLogTools::addFileCurve( RimWellLogTrack* plotTrack, bool showPlotWindow )
{
CVF_ASSERT( plotTrack );
RimWellLogFileCurve* curve = new RimWellLogFileCurve();
RimWellLogLasFileCurve* curve = new RimWellLogLasFileCurve();
cvf::Color3f curveColor = RicWellLogPlotCurveFeatureImpl::curveColorFromTable( plotTrack->curveCount() );
curve->setColor( curveColor );

10
ApplicationLibCode/Commands/RicWellLogTools.h
View File

@ -30,7 +30,7 @@ class Rim3dView;
class Rim3dWellLogCurveCollection;
class RimWellLogExtractionCurve;
class RimWellLogFileChannel;
class RimWellLogFileCurve;
class RimWellLogLasFileCurve;
class RimWellLogRftCurve;
class RimWellLogTrack;
class RimWellLogWbsCurve;
@ -51,10 +51,10 @@ public:
static bool hasRftDataForWell( const QString& wellName );
static bool isWellPathOrSimWellSelectedInView();
static void addWellLogChannelsToPlotTrack( RimWellLogTrack* plotTrack, const std::vector<RimWellLogFileChannel*>& wellLogFileChannels );
static RimWellPath* selectedWellPathWithLogFile();
static RimWellPath* findWellPathWithLogFileFromSelection();
static RimWellLogRftCurve* addRftCurve( RimWellLogTrack* plotTrack, const RimSimWellInView* simWell, bool showPlotWindow = true );
static RimWellLogFileCurve* addFileCurve( RimWellLogTrack* plotTrack, bool showPlotWindow = true );
static RimWellPath* selectedWellPathWithLogFile();
static RimWellPath* findWellPathWithLogFileFromSelection();
static RimWellLogRftCurve* addRftCurve( RimWellLogTrack* plotTrack, const RimSimWellInView* simWell, bool showPlotWindow = true );
static RimWellLogLasFileCurve* addFileCurve( RimWellLogTrack* plotTrack, bool showPlotWindow = true );
static RimWellLogExtractionCurve* addWellLogExtractionCurve( RimWellLogTrack* plotTrack,
RimCase* rimCase,

10
ApplicationLibCode/Commands/WellLogCommands/RicAddWellLogToPlotFeature.cpp
View File

@ -24,9 +24,9 @@
#include "RimMainPlotCollection.h"
#include "RimProject.h"
#include "RimWellLogFile.h"
#include "RimWellLogFileChannel.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogLasFileCurve.h"
#include "RimWellLogPlot.h"
#include "RimWellLogPlotCollection.h"
#include "RimWellLogTrack.h"
@ -74,11 +74,11 @@ void RicAddWellLogToPlotFeature::onActionTriggered( bool isChecked )
RimWellLogFileChannel* wellLog = selection[wlIdx];
auto wellPath = wellLog->firstAncestorOrThisOfType<RimWellPath>();
auto wellLogFile = wellLog->firstAncestorOrThisOfType<RimWellLogFile>();
auto wellLogFile = wellLog->firstAncestorOrThisOfType<RimWellLogLasFile>();
if ( wellLogFile )
{
RimWellLogFileCurve* curve = new RimWellLogFileCurve;
cvf::Color3f curveColor = RicWellLogPlotCurveFeatureImpl::curveColorFromTable( plotTrack->curveCount() );
RimWellLogLasFileCurve* curve = new RimWellLogLasFileCurve;
cvf::Color3f curveColor = RicWellLogPlotCurveFeatureImpl::curveColorFromTable( plotTrack->curveCount() );
curve->setColor( curveColor );
plotTrack->addCurve( curve );

4
ApplicationLibCode/Commands/WellLogCommands/RicChangeDataSourceFeature.cpp
View File

@ -24,7 +24,7 @@
#include "RimWellLogCurve.h"
#include "RimWellLogCurveCommonDataSource.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogLasFileCurve.h"
#include "RimWellLogPlot.h"
#include "RimWellLogTrack.h"
#include "RimWellPath.h"
@ -101,7 +101,7 @@ bool RicChangeDataSourceFeature::selectedTracksAndCurves( std::vector<RimWellLog
{
RimWellLogTrack* wellLogTrack = dynamic_cast<RimWellLogTrack*>( selectedObject );
RimWellLogExtractionCurve* wellLogExtractionCurve = dynamic_cast<RimWellLogExtractionCurve*>( selectedObject );
RimWellLogFileCurve* wellLogFileCurve = dynamic_cast<RimWellLogFileCurve*>( selectedObject );
RimWellLogLasFileCurve* wellLogFileCurve = dynamic_cast<RimWellLogLasFileCurve*>( selectedObject );
if ( wellLogTrack )
{
tracks->push_back( wellLogTrack );

10
ApplicationLibCode/Commands/WellLogCommands/RicMoveWellLogFilesFeature.cpp
View File

@ -20,7 +20,7 @@
#include "RicMoveWellLogFilesFeature.h"
#include "RimProject.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellPath.h"
#include "RiuMainWindow.h"
@ -36,7 +36,7 @@ CAF_CMD_SOURCE_INIT( RicMoveWellLogFilesFeature, "RicMoveWellLogFilesFeature" );
//--------------------------------------------------------------------------------------------------
bool RicMoveWellLogFilesFeature::isCommandEnabled() const
{
RimWellLogFile* selectedWellLogFile = caf::firstAncestorOfTypeFromSelectedObject<RimWellLogFile>();
RimWellLogLasFile* selectedWellLogFile = caf::firstAncestorOfTypeFromSelectedObject<RimWellLogLasFile>();
if ( !selectedWellLogFile ) return false;
@ -55,9 +55,9 @@ void RicMoveWellLogFilesFeature::onActionTriggered( bool isChecked )
{
RimProject* proj = RimProject::current();
RimWellPath* destWellPath = proj->wellPathByName( userData.toString() );
RimWellLogFile* wellLogFile = caf::firstAncestorOfTypeFromSelectedObject<RimWellLogFile>();
RimWellPath* sourceWellPath = caf::firstAncestorOfTypeFromSelectedObject<RimWellPath>();
RimWellPath* destWellPath = proj->wellPathByName( userData.toString() );
RimWellLogLasFile* wellLogFile = caf::firstAncestorOfTypeFromSelectedObject<RimWellLogLasFile>();
RimWellPath* sourceWellPath = caf::firstAncestorOfTypeFromSelectedObject<RimWellPath>();
if ( !destWellPath || !wellLogFile || !sourceWellPath ) return;

4
ApplicationLibCode/Commands/WellLogCommands/RicNewWellBoreStabilityPlotFeature.cpp
View File

@ -36,9 +36,9 @@
#include "RimTools.h"
#include "RimWellBoreStabilityPlot.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellLogFile.h"
#include "RimWellLogFileChannel.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogLasFileCurve.h"
#include "RimWellLogPlotCollection.h"
#include "RimWellLogTrack.h"
#include "RimWellLogWbsCurve.h"

8
ApplicationLibCode/Commands/WellLogCommands/RicNewWellLogFileCurveFeature.cpp
View File

@ -24,9 +24,9 @@
#include "RicWellLogTools.h"
#include "RimTools.h"
#include "RimWellLogFile.h"
#include "RimWellLogFileChannel.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogLasFileCurve.h"
#include "RimWellLogTrack.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"
@ -66,8 +66,8 @@ void RicNewWellLogFileCurveFeature::onActionTriggered( bool isChecked )
RimWellPath* wellPath = RicWellLogTools::selectedWellPathWithLogFile();
if ( wellPath )
{
RimWellLogTrack* newWellLogPlotTrack = RicNewWellLogPlotFeatureImpl::createWellLogPlotTrack();
RimWellLogFileCurve* plotCurve = RicWellLogTools::addFileCurve( newWellLogPlotTrack );
RimWellLogTrack* newWellLogPlotTrack = RicNewWellLogPlotFeatureImpl::createWellLogPlotTrack();
RimWellLogLasFileCurve* plotCurve = RicWellLogTools::addFileCurve( newWellLogPlotTrack );
plotCurve->setWellPath( wellPath );
if ( wellPath->wellLogFiles().size() == 1 )

2
ApplicationLibCode/Commands/WellLogCommands/RicPasteWellLogCurveFeature.cpp
View File

@ -24,7 +24,7 @@
#include "RimWellBoreStabilityPlot.h"
#include "RimWellLogCurve.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogLasFileCurve.h"
#include "RimWellLogRftCurve.h"
#include "RimWellLogTrack.h"
#include "RimWellMeasurementCurve.h"

8
ApplicationLibCode/Commands/WellLogCommands/RicWellLogFileCloseFeature.cpp
View File

@ -21,7 +21,7 @@
#include "RimViewWindow.h"
#include "RimWellAllocationPlot.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogPlot.h"
#include "RimWellPath.h"
#include "RimWellPltPlot.h"
@ -40,7 +40,7 @@ CAF_CMD_SOURCE_INIT( RicWellLogFileCloseFeature, "RicWellLogFileCloseFeature" );
//--------------------------------------------------------------------------------------------------
bool RicWellLogFileCloseFeature::isCommandEnabled() const
{
std::vector<RimWellLogFile*> objects = caf::selectedObjectsByType<RimWellLogFile*>();
std::vector<RimWellLogLasFile*> objects = caf::selectedObjectsByType<RimWellLogLasFile*>();
return !objects.empty();
}
@ -49,7 +49,7 @@ bool RicWellLogFileCloseFeature::isCommandEnabled() const
//--------------------------------------------------------------------------------------------------
void RicWellLogFileCloseFeature::onActionTriggered( bool isChecked )
{
std::vector<RimWellLogFile*> objects = caf::selectedObjectsByType<RimWellLogFile*>();
std::vector<RimWellLogLasFile*> objects = caf::selectedObjectsByType<RimWellLogLasFile*>();
if ( objects.empty() ) return;
@ -85,7 +85,7 @@ void RicWellLogFileCloseFeature::setupActionLook( QAction* actionToSetup )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<RimViewWindow*> RicWellLogFileCloseFeature::referringWellLogPlots( const RimWellLogFile* wellLogFile )
std::set<RimViewWindow*> RicWellLogFileCloseFeature::referringWellLogPlots( const RimWellLogLasFile* wellLogFile )
{
// Remove all curves displaying data from the specified wellLogFile
std::vector<caf::PdmObjectHandle*> referringObjects = wellLogFile->objectsWithReferringPtrFields();

4
ApplicationLibCode/Commands/WellLogCommands/RicWellLogFileCloseFeature.h
View File

@ -22,7 +22,7 @@
#include "cafCmdFeature.h"
#include <set>
class RimWellLogFile;
class RimWellLogLasFile;
class RimViewWindow;
//==================================================================================================
@ -37,5 +37,5 @@ protected:
void onActionTriggered( bool isChecked ) override;
void setupActionLook( QAction* actionToSetup ) override;
std::set<RimViewWindow*> referringWellLogPlots( const RimWellLogFile* wellLogFile );
std::set<RimViewWindow*> referringWellLogPlots( const RimWellLogLasFile* wellLogFile );
};

5
ApplicationLibCode/Commands/WellLogCommands/RicWellLogsImportFileFeature.cpp
View File

@ -37,14 +37,15 @@ CAF_CMD_SOURCE_INIT( RicWellLogsImportFileFeature, "RicWellLogsImportFileFeature
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimWellLogFile*> RicWellLogsImportFileFeature::importWellLogFiles( const QStringList& wellLogFilePaths, QStringList* errorMessages )
std::vector<RimWellLogLasFile*> RicWellLogsImportFileFeature::importWellLogFiles( const QStringList& wellLogFilePaths,
QStringList* errorMessages )
{
RiaApplication* app = RiaApplication::instance();
// Remember the path to next time
app->setLastUsedDialogDirectory( "WELL_LOGS_DIR", QFileInfo( wellLogFilePaths.last() ).absolutePath() );
std::vector<RimWellLogFile*> wellLogFiles = app->addWellLogsToModel( wellLogFilePaths, errorMessages );
std::vector<RimWellLogLasFile*> wellLogFiles = app->addWellLogsToModel( wellLogFilePaths, errorMessages );
caf::PdmUiObjectEditorHandle::updateUiAllObjectEditors();

6
ApplicationLibCode/Commands/WellLogCommands/RicWellLogsImportFileFeature.h
View File

@ -23,7 +23,7 @@
#include <vector>
class RimWellLogFile;
class RimWellLogLasFile;
//==================================================================================================
///
@ -31,8 +31,8 @@ class RimWellLogFile;
class RicWellLogsImportFileFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
static std::vector<RimWellLogFile*> importWellLogFiles( const QStringList& wellLogFilePaths, QStringList* errorMessages );
static QStringList wellLogFileNameFilters();
static std::vector<RimWellLogLasFile*> importWellLogFiles( const QStringList& wellLogFilePaths, QStringList* errorMessages );
static QStringList wellLogFileNameFilters();
protected:
void onActionTriggered( bool isChecked ) override;

6
ApplicationLibCode/FileInterface/RifDataSourceForRftPlt.cpp
View File

@ -26,7 +26,7 @@
#include "RimPressureDepthData.h"
#include "RimSummaryCase.h"
#include "RimSummaryCaseCollection.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "cafAppEnum.h"
#include "cvfAssert.h"
@ -74,7 +74,7 @@ RifDataSourceForRftPlt::RifDataSourceForRftPlt( SourceType sourceType, RimEclips
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RifDataSourceForRftPlt::RifDataSourceForRftPlt( RimWellLogFile* wellLogFile )
RifDataSourceForRftPlt::RifDataSourceForRftPlt( RimWellLogLasFile* wellLogFile )
{
m_sourceType = SourceType::OBSERVED_LAS_FILE;
m_wellLogFile = wellLogFile;
@ -248,7 +248,7 @@ RimSummaryCase* RifDataSourceForRftPlt::summaryCase() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellLogFile* RifDataSourceForRftPlt::wellLogFile() const
RimWellLogLasFile* RifDataSourceForRftPlt::wellLogFile() const
{
return m_wellLogFile;
}

8
ApplicationLibCode/FileInterface/RifDataSourceForRftPlt.h
View File

@ -29,7 +29,7 @@
#include <QMetaType>
#include <QPointer>
class RimWellLogFile;
class RimWellLogLasFile;
class RimEclipseCase;
class RimSummaryCase;
class RimSummaryCaseCollection;
@ -59,7 +59,7 @@ public:
RifDataSourceForRftPlt( SourceType sourceType, RimEclipseCase* eclCase );
RifDataSourceForRftPlt( RimSummaryCaseCollection* ensemble );
RifDataSourceForRftPlt( RimSummaryCase* summaryCase, RimSummaryCaseCollection* ensemble, RimEclipseCase* eclipseCase );
RifDataSourceForRftPlt( RimWellLogFile* wellLogFile );
RifDataSourceForRftPlt( RimWellLogLasFile* wellLogFile );
RifDataSourceForRftPlt( RimObservedFmuRftData* observedFmuRftData );
RifDataSourceForRftPlt( RimPressureDepthData* pressureDepthData );
@ -68,7 +68,7 @@ public:
RimEclipseCase* eclCase() const;
RimSummaryCase* summaryCase() const;
RimSummaryCaseCollection* ensemble() const;
RimWellLogFile* wellLogFile() const;
RimWellLogLasFile* wellLogFile() const;
RimObservedFmuRftData* observedFmuRftData() const;
RimPressureDepthData* pressureDepthData() const;
@ -88,7 +88,7 @@ private:
caf::PdmPointer<RimEclipseCase> m_eclCase;
caf::PdmPointer<RimSummaryCase> m_summaryCase;
caf::PdmPointer<RimSummaryCaseCollection> m_ensemble;
caf::PdmPointer<RimWellLogFile> m_wellLogFile;
caf::PdmPointer<RimWellLogLasFile> m_wellLogFile;
caf::PdmPointer<RimObservedFmuRftData> m_observedFmuRftData;
caf::PdmPointer<RimPressureDepthData> m_pressureDepthData;
};

2
ApplicationLibCode/ProjectDataModel/Flow/RimDataSourceForRftPlt.cpp
View File

@ -22,7 +22,7 @@
#include "RimPressureDepthData.h"
#include "RimSummaryCase.h"
#include "RimSummaryCaseCollection.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "cafAppEnum.h"
#include "cvfAssert.h"

4
ApplicationLibCode/ProjectDataModel/Flow/RimDataSourceForRftPlt.h
View File

@ -35,7 +35,7 @@
class RimObservedFmuRftData;
class RimSummaryCaseCollection;
class RimWellLogFile;
class RimWellLogLasFile;
class RimEclipseCase;
//==================================================================================================
@ -62,7 +62,7 @@ private:
caf::PdmPtrField<RimEclipseCase*> m_eclCase;
caf::PdmPtrField<RimSummaryCase*> m_summaryCase;
caf::PdmPtrField<RimSummaryCaseCollection*> m_ensemble;
caf::PdmPtrField<RimWellLogFile*> m_wellLogFile;
caf::PdmPtrField<RimWellLogLasFile*> m_wellLogFile;
caf::PdmPtrField<RimObservedFmuRftData*> m_observedFmuRftData;
caf::PdmPtrField<RimPressureDepthData*> m_pressureDepthData;
};

12
ApplicationLibCode/ProjectDataModel/Flow/RimWellAllocationOverTimePlot.cpp
View File

@ -40,7 +40,7 @@
#include "RimSimWellInView.h"
#include "RimStackablePlotCurve.h"
#include "RimWellAllocationTools.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellPlotTools.h"
#include "RiuContextMenuLauncher.h"
@ -764,13 +764,13 @@ cvf::Color3f RimWellAllocationOverTimePlot::getTracerColor( const QString& trace
//--------------------------------------------------------------------------------------------------
QString RimWellAllocationOverTimePlot::getValueTypeText() const
{
RiaDefines::EclipseUnitSystem unitSet = m_case->eclipseCaseData()->unitsType();
RimWellLogFile::WellFlowCondition condition = m_flowDiagSolution ? RimWellLogFile::WELL_FLOW_COND_RESERVOIR
: RimWellLogFile::WELL_FLOW_COND_STANDARD;
RiaDefines::EclipseUnitSystem unitSet = m_case->eclipseCaseData()->unitsType();
RimWellLogLasFile::WellFlowCondition condition = m_flowDiagSolution ? RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR
: RimWellLogLasFile::WELL_FLOW_COND_STANDARD;
if ( m_flowValueType == FlowValueType::FLOW_RATE_PERCENTAGE )
{
QString conditionText = condition == RimWellLogFile::WELL_FLOW_COND_RESERVOIR ? "Reservoir" : "Surface";
QString conditionText = condition == RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR ? "Reservoir" : "Surface";
return QString( "Percentage of %1 Flow Rate [%]" ).arg( conditionText );
}
if ( m_flowValueType == FlowValueType::FLOW_RATE )
@ -787,7 +787,7 @@ QString RimWellAllocationOverTimePlot::getValueTypeText() const
}
if ( m_flowValueType == FlowValueType::ACCUMULATED_FLOW_VOLUME_PERCENTAGE )
{
QString conditionText = condition == RimWellLogFile::WELL_FLOW_COND_RESERVOIR ? "Reservoir" : "Surface";
QString conditionText = condition == RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR ? "Reservoir" : "Surface";
return QString( "Accumulated %1 Flow Volume Allocation [%]" ).arg( conditionText );
}

8
ApplicationLibCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp
View File

@ -45,7 +45,7 @@
#include "RimWellAllocationTools.h"
#include "RimWellFlowRateCurve.h"
#include "RimWellLogCurveCommonDataSource.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogPlot.h"
#include "RimWellLogTrack.h"
#include "RimWellPlotTools.h"
@ -440,9 +440,9 @@ void RimWellAllocationPlot::updateFromWell()
//--------------------------------------------------------------------------------------------------
void RimWellAllocationPlot::updateWellFlowPlotXAxisTitle( RimWellLogTrack* plotTrack )
{
RiaDefines::EclipseUnitSystem unitSet = m_case->eclipseCaseData()->unitsType();
RimWellLogFile::WellFlowCondition condition = m_flowDiagSolution ? RimWellLogFile::WELL_FLOW_COND_RESERVOIR
: RimWellLogFile::WELL_FLOW_COND_STANDARD;
RiaDefines::EclipseUnitSystem unitSet = m_case->eclipseCaseData()->unitsType();
RimWellLogLasFile::WellFlowCondition condition = m_flowDiagSolution ? RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR
: RimWellLogLasFile::WELL_FLOW_COND_STANDARD;
QString axisTitle = RimWellPlotTools::flowPlotAxisTitle( condition, unitSet );
plotTrack->setPropertyValueAxisTitle( axisTitle );

6
ApplicationLibCode/ProjectDataModel/Flow/RimWellConnectivityTable.cpp
View File

@ -40,7 +40,7 @@
#include "RimSimWellInView.h"
#include "RimTools.h"
#include "RimWellAllocationTools.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellPlotTools.h"
#include "RiuMatrixPlotWidget.h"
@ -919,8 +919,8 @@ std::vector<QString> RimWellConnectivityTable::getProductionWellNamesAtTimeSteps
//--------------------------------------------------------------------------------------------------
QString RimWellConnectivityTable::createTableTitle() const
{
RiaDefines::EclipseUnitSystem unitSet = m_case->eclipseCaseData()->unitsType();
RimWellLogFile::WellFlowCondition condition = RimWellLogFile::WELL_FLOW_COND_RESERVOIR;
RiaDefines::EclipseUnitSystem unitSet = m_case->eclipseCaseData()->unitsType();
RimWellLogLasFile::WellFlowCondition condition = RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR;
auto timeSampleValueTypeText = [&]() -> QString
{

68
ApplicationLibCode/ProjectDataModel/Flow/RimWellPlotTools.cpp
View File

@ -38,9 +38,9 @@
#include "RimSummaryCase.h"
#include "RimSummaryCaseCollection.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellLogFile.h"
#include "RimWellLogFileChannel.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogLasFileCurve.h"
#include "RimWellLogRftCurve.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"
@ -78,7 +78,7 @@ public:
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimWellPlotTools::hasPressureData( const RimWellLogFile* wellLogFile )
bool RimWellPlotTools::hasPressureData( const RimWellLogLasFile* wellLogFile )
{
for ( RimWellLogFileChannel* const wellLogChannel : wellLogFile->wellLogChannels() )
{
@ -92,7 +92,7 @@ bool RimWellPlotTools::hasPressureData( const RimWellLogFile* wellLogFile )
//--------------------------------------------------------------------------------------------------
bool RimWellPlotTools::hasPressureData( RimWellPath* wellPath )
{
for ( RimWellLogFile* const wellLogFile : wellPath->wellLogFiles() )
for ( RimWellLogLasFile* const wellLogFile : wellPath->wellLogFiles() )
{
if ( hasPressureData( wellLogFile ) )
{
@ -144,7 +144,7 @@ bool RimWellPlotTools::hasPressureData( RimEclipseResultCase* gridCase )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimWellPlotTools::hasFlowData( const RimWellLogFile* wellLogFile )
bool RimWellPlotTools::hasFlowData( const RimWellLogLasFile* wellLogFile )
{
for ( RimWellLogFileChannel* const wellLogChannel : wellLogFile->wellLogChannels() )
{
@ -158,7 +158,7 @@ bool RimWellPlotTools::hasFlowData( const RimWellLogFile* wellLogFile )
//--------------------------------------------------------------------------------------------------
bool RimWellPlotTools::hasFlowData( const RimWellPath* wellPath )
{
for ( RimWellLogFile* const wellLogFile : wellPath->wellLogFiles() )
for ( RimWellLogLasFile* const wellLogFile : wellPath->wellLogFiles() )
{
if ( hasFlowData( wellLogFile ) )
{
@ -268,20 +268,20 @@ void RimWellPlotTools::addTimeStepsToMap( std::map<QDateTime, std::set<RifDataSo
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimWellLogFile*> RimWellPlotTools::wellLogFilesContainingPressure( const QString& wellPathNameOrSimWellName )
std::vector<RimWellLogLasFile*> RimWellPlotTools::wellLogFilesContainingPressure( const QString& wellPathNameOrSimWellName )
{
std::vector<RimWellLogFile*> wellLogFiles;
const RimProject* const project = RimProject::current();
std::vector<RimWellPath*> wellPaths = project->allWellPaths();
std::vector<RimWellLogLasFile*> wellLogFiles;
const RimProject* const project = RimProject::current();
std::vector<RimWellPath*> wellPaths = project->allWellPaths();
for ( auto wellPath : wellPaths )
{
if ( !wellPathNameOrSimWellName.isEmpty() &&
( wellPathNameOrSimWellName == wellPath->associatedSimulationWellName() || wellPathNameOrSimWellName == wellPath->name() ) )
{
const std::vector<RimWellLogFile*> files = wellPath->wellLogFiles();
const std::vector<RimWellLogLasFile*> files = wellPath->wellLogFiles();
for ( RimWellLogFile* file : files )
for ( RimWellLogLasFile* file : files )
{
if ( hasPressureData( file ) )
{
@ -297,7 +297,7 @@ std::vector<RimWellLogFile*> RimWellPlotTools::wellLogFilesContainingPressure( c
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellLogFileChannel* RimWellPlotTools::getPressureChannelFromWellFile( const RimWellLogFile* wellLogFile )
RimWellLogFileChannel* RimWellPlotTools::getPressureChannelFromWellFile( const RimWellLogLasFile* wellLogFile )
{
if ( wellLogFile != nullptr )
{
@ -315,19 +315,19 @@ RimWellLogFileChannel* RimWellPlotTools::getPressureChannelFromWellFile( const R
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimWellLogFile*> RimWellPlotTools::wellLogFilesContainingFlow( const QString& wellPathName )
std::vector<RimWellLogLasFile*> RimWellPlotTools::wellLogFilesContainingFlow( const QString& wellPathName )
{
std::vector<RimWellLogFile*> wellLogFiles;
const RimProject* const project = RimProject::current();
std::vector<RimWellPath*> wellPaths = project->allWellPaths();
std::vector<RimWellLogLasFile*> wellLogFiles;
const RimProject* const project = RimProject::current();
std::vector<RimWellPath*> wellPaths = project->allWellPaths();
for ( auto wellPath : wellPaths )
{
if ( wellPath->name() == wellPathName )
{
std::vector<RimWellLogFile*> files = wellPath->wellLogFiles();
std::vector<RimWellLogLasFile*> files = wellPath->wellLogFiles();
for ( RimWellLogFile* file : files )
for ( RimWellLogLasFile* file : files )
{
if ( hasFlowData( file ) )
{
@ -342,14 +342,14 @@ std::vector<RimWellLogFile*> RimWellPlotTools::wellLogFilesContainingFlow( const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellPath* RimWellPlotTools::wellPathFromWellLogFile( const RimWellLogFile* wellLogFile )
RimWellPath* RimWellPlotTools::wellPathFromWellLogFile( const RimWellLogLasFile* wellLogFile )
{
RimProject* const project = RimProject::current();
for ( const auto& oilField : project->oilFields )
{
for ( const auto& wellPath : oilField->wellPathCollection()->allWellPaths() )
{
for ( RimWellLogFile* const file : wellPath->wellLogFiles() )
for ( RimWellLogLasFile* const file : wellPath->wellLogFiles() )
{
if ( file == wellLogFile )
{
@ -616,7 +616,7 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve( const RimWellLogCu
{
const RimWellLogRftCurve* rftCurve = dynamic_cast<const RimWellLogRftCurve*>( curve );
const RimWellLogExtractionCurve* gridCurve = dynamic_cast<const RimWellLogExtractionCurve*>( curve );
const RimWellLogFileCurve* wellLogFileCurve = dynamic_cast<const RimWellLogFileCurve*>( curve );
const RimWellLogLasFileCurve* wellLogFileCurve = dynamic_cast<const RimWellLogLasFileCurve*>( curve );
if ( rftCurve != nullptr )
{
@ -676,7 +676,7 @@ RiaRftPltCurveDefinition RimWellPlotTools::curveDefFromCurve( const RimWellLogCu
}
else if ( wellLogFileCurve != nullptr )
{
RimWellLogFile* const wellLogFile = wellLogFileCurve->wellLogFile();
RimWellLogLasFile* const wellLogFile = wellLogFileCurve->wellLogFile();
if ( wellLogFile != nullptr )
{
@ -869,11 +869,11 @@ std::set<RiaRftPltCurveDefinition>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimWellPlotTools::flowPlotAxisTitle( RimWellLogFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem )
QString RimWellPlotTools::flowPlotAxisTitle( RimWellLogLasFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem )
{
QString axisTitle;
if ( condition == RimWellLogFile::WELL_FLOW_COND_RESERVOIR )
if ( condition == RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR )
{
QString unitText = RimWellPlotTools::flowUnitText( condition, unitSystem );
@ -917,11 +917,11 @@ QString flowConditionReservoirUnitText( RiaDefines::EclipseUnitSystem unitSystem
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimWellPlotTools::flowUnitText( RimWellLogFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem )
QString RimWellPlotTools::flowUnitText( RimWellLogLasFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem )
{
QString unitText;
if ( condition == RimWellLogFile::WELL_FLOW_COND_RESERVOIR )
if ( condition == RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR )
{
unitText = flowConditionReservoirUnitText( unitSystem );
}
@ -949,11 +949,11 @@ QString RimWellPlotTools::flowUnitText( RimWellLogFile::WellFlowCondition condit
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimWellPlotTools::flowVolumePlotAxisTitle( RimWellLogFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem )
QString RimWellPlotTools::flowVolumePlotAxisTitle( RimWellLogLasFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem )
{
QString axisTitle;
if ( condition == RimWellLogFile::WELL_FLOW_COND_RESERVOIR )
if ( condition == RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR )
{
QString unitText = RimWellPlotTools::flowVolumeUnitText( condition, unitSystem );
@ -997,11 +997,11 @@ QString flowVolumeConditionReservoirUnitText( RiaDefines::EclipseUnitSystem unit
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimWellPlotTools::flowVolumeUnitText( RimWellLogFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem )
QString RimWellPlotTools::flowVolumeUnitText( RimWellLogLasFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem )
{
QString unitText;
if ( condition == RimWellLogFile::WELL_FLOW_COND_RESERVOIR )
if ( condition == RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR )
{
unitText = flowVolumeConditionReservoirUnitText( unitSystem );
}
@ -1029,11 +1029,13 @@ QString RimWellPlotTools::flowVolumeUnitText( RimWellLogFile::WellFlowCondition
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimWellPlotTools::curveUnitText( RimWellLogFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem, FlowPhase flowPhase )
QString RimWellPlotTools::curveUnitText( RimWellLogLasFile::WellFlowCondition condition,
RiaDefines::EclipseUnitSystem unitSystem,
FlowPhase flowPhase )
{
QString unitText;
if ( condition == RimWellLogFile::WELL_FLOW_COND_RESERVOIR )
if ( condition == RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR )
{
unitText = flowConditionReservoirUnitText( unitSystem );
}

31
ApplicationLibCode/ProjectDataModel/Flow/RimWellPlotTools.h
View File

@ -24,7 +24,7 @@
#include "RifDataSourceForRftPltQMetaType.h"
#include "RifEclipseRftAddress.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include <QMetaType>
@ -75,24 +75,24 @@ public:
static bool isTotalFlowChannel( const QString& channelName );
static FlowPhase flowPhaseFromChannelName( const QString& channelName );
static std::vector<RimWellLogFile*> wellLogFilesContainingFlow( const QString& wellName );
static RimWellPath* wellPathByWellPathNameOrSimWellName( const QString& wellPathNameOrSimwellName );
static std::vector<RimWellLogLasFile*> wellLogFilesContainingFlow( const QString& wellName );
static RimWellPath* wellPathByWellPathNameOrSimWellName( const QString& wellPathNameOrSimwellName );
// RFT Only
private:
static std::pair<RigEclipseResultAddress, QString> pressureResultDataInfo( const RigEclipseCaseData* eclipseCaseData );
public:
static void addTimeStepsToMap( std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& destMap,
const std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepsToAdd );
static std::vector<RimWellLogFile*> wellLogFilesContainingPressure( const QString& wellPathNameOrSimWellName );
static RimWellLogFileChannel* getPressureChannelFromWellFile( const RimWellLogFile* wellLogFile );
static RimWellPath* wellPathFromWellLogFile( const RimWellLogFile* wellLogFile );
static void addTimeStepsToMap( std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& destMap,
const std::map<QDateTime, std::set<RifDataSourceForRftPlt>>& timeStepsToAdd );
static std::vector<RimWellLogLasFile*> wellLogFilesContainingPressure( const QString& wellPathNameOrSimWellName );
static RimWellLogFileChannel* getPressureChannelFromWellFile( const RimWellLogLasFile* wellLogFile );
static RimWellPath* wellPathFromWellLogFile( const RimWellLogLasFile* wellLogFile );
static std::map<QDateTime, std::set<RifDataSourceForRftPlt>> timeStepsMapFromGridCase( RimEclipseCase* gridCase );
static RiaRftPltCurveDefinition curveDefFromCurve( const RimWellLogCurve* curve );
// others
static bool hasFlowData( const RimWellLogFile* wellLogFile );
static bool hasFlowData( const RimWellLogLasFile* wellLogFile );
static bool hasAssociatedWellPath( const QString& wellName );
// Both
@ -121,12 +121,13 @@ public:
const std::vector<RifDataSourceForRftPlt>& selectedSourcesExpanded,
const std::set<RifEclipseRftAddress::RftWellLogChannelType>& interestingRFTResults );
static QString flowPlotAxisTitle( RimWellLogFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem );
static QString flowUnitText( RimWellLogFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem );
static QString flowVolumePlotAxisTitle( RimWellLogFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem );
static QString flowVolumeUnitText( RimWellLogFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem );
static QString flowPlotAxisTitle( RimWellLogLasFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem );
static QString flowUnitText( RimWellLogLasFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem );
static QString flowVolumePlotAxisTitle( RimWellLogLasFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem );
static QString flowVolumeUnitText( RimWellLogLasFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem );
static QString curveUnitText( RimWellLogFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem, FlowPhase flowPhase );
static QString
curveUnitText( RimWellLogLasFile::WellFlowCondition condition, RiaDefines::EclipseUnitSystem unitSystem, FlowPhase flowPhase );
static bool hasFlowData( const RimWellPath* wellPath );
@ -144,7 +145,7 @@ private:
static std::set<QString> FLOW_DATA_NAMES;
static bool hasPressureData( const RimWellLogFile* wellLogFile );
static bool hasPressureData( const RimWellLogLasFile* wellLogFile );
static bool isPressureChannel( RimWellLogFileChannel* channel );
static bool hasPressureData( RimEclipseResultCase* gridCase );
static bool hasPressureData( RimWellPath* wellPath );

18
ApplicationLibCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
View File

@ -48,9 +48,9 @@
#include "RimSummaryCurveAppearanceCalculator.h"
#include "RimWellFlowRateCurve.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellLogFile.h"
#include "RimWellLogFileChannel.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogLasFileCurve.h"
#include "RimWellLogPlot.h"
#include "RimWellLogPlotCollection.h"
#include "RimWellLogPlotNameConfig.h"
@ -178,10 +178,10 @@ void RimWellPltPlot::setPlotXAxisTitles( RimWellLogTrack* plotTrack )
QString axisTitle;
if ( m_useReservoirConditionCurves )
axisTitle += RimWellPlotTools::flowPlotAxisTitle( RimWellLogFile::WELL_FLOW_COND_RESERVOIR, unitSet );
axisTitle += RimWellPlotTools::flowPlotAxisTitle( RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR, unitSet );
if ( m_useReservoirConditionCurves && m_useStandardConditionCurves ) axisTitle += " | ";
if ( m_useStandardConditionCurves )
axisTitle += RimWellPlotTools::flowPlotAxisTitle( RimWellLogFile::WELL_FLOW_COND_STANDARD, unitSet );
axisTitle += RimWellPlotTools::flowPlotAxisTitle( RimWellLogLasFile::WELL_FLOW_COND_STANDARD, unitSet );
plotTrack->setPropertyValueAxisTitle( axisTitle );
@ -533,7 +533,7 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
const std::vector<double>& depthValues = wfTotalAccumulator.pseudoLengthFromTop( 0 );
QString curveUnitText = RimWellPlotTools::flowUnitText( RimWellLogFile::WELL_FLOW_COND_RESERVOIR, unitSet );
QString curveUnitText = RimWellPlotTools::flowUnitText( RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR, unitSet );
const std::vector<double> accFlow = wfTotalAccumulator.accumulatedTracerFlowPrPseudoLength( RIG_FLOW_TOTAL_NAME, 0 );
addStackedCurve( curveName + ", " + RIG_FLOW_TOTAL_NAME + " " + curveUnitText,
@ -574,7 +574,7 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
else if ( tracerName == RIG_FLOW_WATER_NAME )
flowPhase = FLOW_PHASE_WATER;
QString curveUnitText =
RimWellPlotTools::curveUnitText( RimWellLogFile::WELL_FLOW_COND_STANDARD, unitSet, flowPhase );
RimWellPlotTools::curveUnitText( RimWellLogLasFile::WELL_FLOW_COND_STANDARD, unitSet, flowPhase );
const std::vector<double>& accFlow = wfPhaseAccumulator.accumulatedTracerFlowPrPseudoLength( tracerName, 0 );
addStackedCurve( curveName + ", " + tracerName + " " + curveUnitText,
@ -593,10 +593,10 @@ void RimWellPltPlot::syncCurvesFromUiSelection()
{
if ( sourceDef.wellLogFile() && sourceDef.wellLogFile()->wellLogFileData() )
{
RimWellLogFile::WellFlowCondition flowCondition = sourceDef.wellLogFile()->wellFlowRateCondition();
RimWellLogLasFile::WellFlowCondition flowCondition = sourceDef.wellLogFile()->wellFlowRateCondition();
if ( ( m_useStandardConditionCurves() && flowCondition == RimWellLogFile::WELL_FLOW_COND_STANDARD ) ||
( m_useReservoirConditionCurves() && flowCondition == RimWellLogFile::WELL_FLOW_COND_RESERVOIR ) )
if ( ( m_useStandardConditionCurves() && flowCondition == RimWellLogLasFile::WELL_FLOW_COND_STANDARD ) ||
( m_useReservoirConditionCurves() && flowCondition == RimWellLogLasFile::WELL_FLOW_COND_RESERVOIR ) )
{
using ChannelValNameIdxTuple = std::tuple<double, QString, int>;

16
ApplicationLibCode/ProjectDataModel/Flow/RimWellRftPlot.cpp
View File

@ -48,9 +48,9 @@
#include "RimSummaryCaseCollection.h"
#include "RimTools.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellLogFile.h"
#include "RimWellLogFileChannel.h"
#include "RimWellLogFileCurve.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogLasFileCurve.h"
#include "RimWellLogPlot.h"
#include "RimWellLogPlotNameConfig.h"
#include "RimWellLogRftCurve.h"
@ -268,10 +268,10 @@ void RimWellRftPlot::applyInitialSelections()
sourcesToSelect.push_back( RifDataSourceForRftPlt( ensemble ) );
}
std::vector<RimWellLogFile*> wellLogFiles = RimWellPlotTools::wellLogFilesContainingPressure( m_wellPathNameOrSimWellName );
std::vector<RimWellLogLasFile*> wellLogFiles = RimWellPlotTools::wellLogFilesContainingPressure( m_wellPathNameOrSimWellName );
if ( !wellLogFiles.empty() )
{
for ( RimWellLogFile* const wellLogFile : wellLogFiles )
for ( RimWellLogLasFile* const wellLogFile : wellLogFiles )
{
sourcesToSelect.push_back( RifDataSourceForRftPlt( wellLogFile ) );
}
@ -655,12 +655,12 @@ void RimWellRftPlot::updateCurvesInPlot( const std::set<RiaRftPltCurveDefinition
}
else if ( curveDefToAdd.address().sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE )
{
RimWellLogFile* const wellLogFile = curveDefToAdd.address().wellLogFile();
RimWellPath* const wellPath = RimWellPlotTools::wellPathFromWellLogFile( wellLogFile );
RimWellLogLasFile* const wellLogFile = curveDefToAdd.address().wellLogFile();
RimWellPath* const wellPath = RimWellPlotTools::wellPathFromWellLogFile( wellLogFile );
if ( wellLogFile != nullptr )
{
RimWellLogFileChannel* pressureChannel = RimWellPlotTools::getPressureChannelFromWellFile( wellLogFile );
auto curve = new RimWellLogFileCurve();
auto curve = new RimWellLogLasFileCurve();
plotTrack->addCurve( curve );
curve->setWellPath( wellPath );
@ -695,7 +695,7 @@ std::vector<RifDataSourceForRftPlt> RimWellRftPlot::selectedSourcesExpanded() co
{
if ( addr.sourceType() == RifDataSourceForRftPlt::SourceType::OBSERVED_LAS_FILE )
{
for ( RimWellLogFile* const wellLogFile : RimWellPlotTools::wellLogFilesContainingPressure( m_wellPathNameOrSimWellName ) )
for ( RimWellLogLasFile* const wellLogFile : RimWellPlotTools::wellLogFilesContainingPressure( m_wellPathNameOrSimWellName ) )
{
sources.push_back( RifDataSourceForRftPlt( wellLogFile ) );
}

4
ApplicationLibCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@ -156,8 +156,8 @@
#include "RimWellAllocationPlot.h"
#include "RimWellIASettings.h"
#include "RimWellLogCurve.h"
#include "RimWellLogFile.h"
#include "RimWellLogFileChannel.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogPlot.h"
#include "RimWellLogPlotCollection.h"
#include "RimWellLogTrack.h"
@ -500,7 +500,7 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
menuBuilder << "RicAdd3dWellLogFileCurveFeature";
menuBuilder << "RicAdd3dWellLogRftCurveFeature";
}
else if ( dynamic_cast<RimWellLogFile*>( firstUiItem ) )
else if ( dynamic_cast<RimWellLogLasFile*>( firstUiItem ) )
{
menuBuilder << "RicWellPathsImportFileFeature";
menuBuilder << "RicWellLogsImportFileFeature";

2
ApplicationLibCode/ProjectDataModel/RimProject.cpp
View File

@ -92,7 +92,7 @@
#include "RimViewLinker.h"
#include "RimViewLinkerCollection.h"
#include "RimViewWindow.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogPlotCollection.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"

2
ApplicationLibCode/ProjectDataModel/RimTools.cpp
View File

@ -38,7 +38,7 @@
#include "RimSeismicDataCollection.h"
#include "RimSeismicDifferenceData.h"
#include "RimSurfaceCollection.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"

4
ApplicationLibCode/ProjectDataModel/RimWbsParameters.cpp
View File

@ -23,7 +23,7 @@
#include "RigGeoMechCaseData.h"
#include "RimGeoMechCase.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellPath.h"
#include "cafPdmFieldScriptingCapability.h"
@ -378,7 +378,7 @@ void RimWbsParameters::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderin
//--------------------------------------------------------------------------------------------------
bool RimWbsParameters::hasLasFileWithChannel( const QString& channel ) const
{
return m_wellPath && !RimWellLogFile::findMdAndChannelValuesForWellPath( m_wellPath, channel ).empty();
return m_wellPath && !RimWellLogLasFile::findMdAndChannelValuesForWellPath( m_wellPath, channel ).empty();
}
//--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/ProjectDataModel/RimWellBoreStabilityPlot.cpp
View File

@ -29,7 +29,7 @@
#include "RimTools.h"
#include "RimWbsParameters.h"
#include "RimWellLogCurveCommonDataSource.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogPlotNameConfig.h"
#include "cafPdmBase.h"

2
ApplicationLibCode/ProjectDataModel/StimPlanModel/RimStimPlanModelElasticPropertyCalculator.cpp
View File

@ -47,7 +47,7 @@
#include "RimStimPlanModelElasticPropertyCalculator.h"
#include "RimStimPlanModelTemplate.h"
#include "RimTools.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogPlot.h"
#include "RimWellLogTrack.h"
#include "RimWellPath.h"

14
ApplicationLibCode/ProjectDataModel/WellLog/CMakeLists_files.cmake
View File

@ -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

2
ApplicationLibCode/ProjectDataModel/WellLog/Rim3dWellLogExtractionCurve.cpp
View File

@ -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"

8
ApplicationLibCode/ProjectDataModel/WellLog/Rim3dWellLogFileCurve.cpp
View File

@ -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 ) );

10
ApplicationLibCode/ProjectDataModel/WellLog/Rim3dWellLogFileCurve.h
View File

@ -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;
};

34
ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogCurveSet.cpp
View File

@ -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;

20
ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogCurveSet.h
View File

@ -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 );

20
ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogStatistics.cpp
View File

@ -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 ) )

10
ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogStatistics.h
View File

@ -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;

8
ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogs.cpp
View File

@ -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();
}

10
ApplicationLibCode/ProjectDataModel/WellLog/RimEnsembleWellLogs.h
View File

@ -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;
};

8
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogCurveCommonDataSource.cpp
View File

@ -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 );

4
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogExtractionCurve.cpp
View File

@ -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 );

56
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogFile.cpp → ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFile.cpp
View File

@ -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;
}

10
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogFile.h → ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFile.h
View File

@ -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 );

52
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogFileCurve.cpp → ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFileCurve.cpp
View File

@ -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 )
{

20
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogFileCurve.h → ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFileCurve.h
View File

@ -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;
};

8
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogFileCurveNameConfig.cpp → ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFileCurveNameConfig.cpp
View File

@ -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 )
{
}

4
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogFileCurveNameConfig.h → ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogLasFileCurveNameConfig.h
View File

@ -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;

2
ApplicationLibCode/ProjectDataModel/WellMeasurement/RimWellMeasurementCurve.cpp
View File

@ -24,7 +24,7 @@
#include "RimDepthTrackPlot.h"
#include "RimProject.h"
#include "RimTools.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogTrack.h"
#include "RimWellMeasurement.h"
#include "RimWellMeasurementCollection.h"

20
ApplicationLibCode/ProjectDataModel/WellPath/RimWellPath.cpp
View File

@ -43,8 +43,8 @@
#include "RimStimPlanModelCollection.h"
#include "RimTools.h"
#include "RimWellIASettingsCollection.h"
#include "RimWellLogFile.h"
#include "RimWellLogFileChannel.h"
#include "RimWellLogLasFile.h"
#include "RimWellLogPlotCollection.h"
#include "RimWellPathAttributeCollection.h"
#include "RimWellPathCollection.h"
@ -578,18 +578,18 @@ void RimWellPath::setNameNoUpdateOfExportName( const QString& name )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimWellLogFile*> RimWellPath::wellLogFiles() const
std::vector<RimWellLogLasFile*> RimWellPath::wellLogFiles() const
{
return std::vector<RimWellLogFile*>( m_wellLogFiles.begin(), m_wellLogFiles.end() );
return std::vector<RimWellLogLasFile*>( m_wellLogFiles.begin(), m_wellLogFiles.end() );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellLogFile* RimWellPath::firstWellLogFileMatchingChannelName( const QString& channelName ) const
RimWellLogLasFile* RimWellPath::firstWellLogFileMatchingChannelName( const QString& channelName ) const
{
std::vector<RimWellLogFile*> allWellLogFiles = wellLogFiles();
for ( RimWellLogFile* logFile : allWellLogFiles )
std::vector<RimWellLogLasFile*> allWellLogFiles = wellLogFiles();
for ( RimWellLogLasFile* logFile : allWellLogFiles )
{
std::vector<RimWellLogFileChannel*> channels = logFile->wellLogChannels();
for ( RimWellLogFileChannel* channel : channels )
@ -895,12 +895,12 @@ double RimWellPath::datumElevation() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPath::addWellLogFile( RimWellLogFile* logFileInfo )
void RimWellPath::addWellLogFile( RimWellLogLasFile* logFileInfo )
{
// Prevent the same file from being loaded more than once
auto itr = std::find_if( m_wellLogFiles.begin(),
m_wellLogFiles.end(),
[&]( const RimWellLogFile* file )
[&]( const RimWellLogLasFile* file )
{ return QString::compare( file->fileName(), logFileInfo->fileName(), Qt::CaseInsensitive ) == 0; } );
// Todo: Verify well name to ensure all well log files having the same well name
@ -919,7 +919,7 @@ void RimWellPath::addWellLogFile( RimWellLogFile* logFileInfo )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPath::deleteWellLogFile( RimWellLogFile* logFileInfo )
void RimWellPath::deleteWellLogFile( RimWellLogLasFile* logFileInfo )
{
detachWellLogFile( logFileInfo );
delete logFileInfo;
@ -928,7 +928,7 @@ void RimWellPath::deleteWellLogFile( RimWellLogFile* logFileInfo )
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPath::detachWellLogFile( RimWellLogFile* logFileInfo )
void RimWellPath::detachWellLogFile( RimWellLogLasFile* logFileInfo )
{
auto pdmObject = dynamic_cast<caf::PdmObjectHandle*>( logFileInfo );
for ( size_t i = 0; i < m_wellLogFiles.size(); i++ )

14
ApplicationLibCode/ProjectDataModel/WellPath/RimWellPath.h
View File

@ -47,7 +47,7 @@ class RigWellPath;
class RigWellPathFormations;
class RimProject;
class RimWellLogFile;
class RimWellLogLasFile;
class RimFractureTemplateCollection;
class RimStimPlanModelCollection;
class RimFishbonesCollection;
@ -104,11 +104,11 @@ public:
double uniqueStartMD() const;
double uniqueEndMD() const;
void addWellLogFile( RimWellLogFile* logFileInfo );
void deleteWellLogFile( RimWellLogFile* logFileInfo );
void detachWellLogFile( RimWellLogFile* logFileInfo );
std::vector<RimWellLogFile*> wellLogFiles() const;
RimWellLogFile* firstWellLogFileMatchingChannelName( const QString& channelName ) const;
void addWellLogFile( RimWellLogLasFile* logFileInfo );
void deleteWellLogFile( RimWellLogLasFile* logFileInfo );
void detachWellLogFile( RimWellLogLasFile* logFileInfo );
std::vector<RimWellLogLasFile*> wellLogFiles() const;
RimWellLogLasFile* firstWellLogFileMatchingChannelName( const QString& channelName ) const;
void setFormationsGeometry( cvf::ref<RigWellPathFormations> wellPathFormations );
bool readWellPathFormationsFile( QString* errorMessage, RifWellPathFormationsImporter* wellPathFormationsImporter );
@ -209,7 +209,7 @@ private:
caf::PdmField<double> m_wellPathRadiusScaleFactor;
caf::PdmField<cvf::Color3f> m_wellPathColor;
caf::PdmChildArrayField<RimWellLogFile*> m_wellLogFiles;
caf::PdmChildArrayField<RimWellLogLasFile*> m_wellLogFiles;
caf::PdmChildField<Rim3dWellLogCurveCollection*> m_3dWellLogCurves;
caf::PdmChildField<RimWellPathCompletionSettings*> m_completionSettings;
caf::PdmChildField<RimWellPathCompletions*> m_completions;

12
ApplicationLibCode/ProjectDataModel/WellPath/RimWellPathCollection.cpp
View File

@ -44,7 +44,7 @@
#include "RimProject.h"
#include "RimStimPlanModel.h"
#include "RimStimPlanModelCollection.h"
#include "RimWellLogFile.h"
#include "RimWellLogLasFile.h"
#include "RimWellMeasurementCollection.h"
#include "RimWellPath.h"
#include "RimWellPathCompletionSettings.h"
@ -169,7 +169,7 @@ void RimWellPathCollection::loadDataAndUpdate()
if ( wellPath )
{
for ( RimWellLogFile* const wellLogFile : wellPath->wellLogFiles() )
for ( RimWellLogLasFile* const wellLogFile : wellPath->wellLogFiles() )
{
if ( wellLogFile )
{
@ -352,16 +352,16 @@ void RimWellPathCollection::addWellPaths( const std::vector<RimWellPath*> incomi
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimWellLogFile*> RimWellPathCollection::addWellLogs( const QStringList& filePaths, QStringList* errorMessages )
std::vector<RimWellLogLasFile*> RimWellPathCollection::addWellLogs( const QStringList& filePaths, QStringList* errorMessages )
{
CAF_ASSERT( errorMessages );
std::vector<RimWellLogFile*> logFileInfos;
std::vector<RimWellLogLasFile*> logFileInfos;
foreach ( QString filePath, filePaths )
{
QString errorMessage;
RimWellLogFile* logFileInfo = RimWellLogFile::readWellLogFile( filePath, &errorMessage );
QString errorMessage;
RimWellLogLasFile* logFileInfo = RimWellLogLasFile::readWellLogFile( filePath, &errorMessage );
if ( !errorMessage.isEmpty() )
{
errorMessages->push_back( errorMessage );

6
ApplicationLibCode/ProjectDataModel/WellPath/RimWellPathCollection.h
View File

@ -43,7 +43,7 @@ class RigWellPath;
class RimFileWellPath;
class RimEclipseView;
class RimProject;
class RimWellLogFile;
class RimWellLogLasFile;
class RimWellPath;
class RifWellPathFormationsImporter;
class RimWellMeasurementCollection;
@ -114,8 +114,8 @@ public:
void addWellPaths( const std::vector<RimWellPath*> incomingWellPaths );
void addWellPath( gsl::not_null<RimWellPath*> wellPath );
std::vector<RimWellLogFile*> addWellLogs( const QStringList& filePaths, QStringList* errorMessages );
void addWellPathFormations( const QStringList& filePaths );
std::vector<RimWellLogLasFile*> addWellLogs( const QStringList& filePaths, QStringList* errorMessages );
void addWellPathFormations( const QStringList& filePaths );
void scheduleRedrawAffectedViews();