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

#1559 Use common export completions command for well paths and simulation wells

Browse Source
This commit is contained in:
Bjørnar Grip Fjær 2017-06-12 12:03:42 +02:00
parent 95dd87f23c
commit 6391fad018
11 changed files with 230 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
ApplicationCode/Commands/CompletionCommands/RicExportCompletionDataSettingsUi.cpp
View File

@ -40,6 +40,22 @@ RicExportCompletionDataSettingsUi::RicExportCompletionDataSettingsUi()
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicExportCompletionDataSettingsUi::showForSimWells()
{
m_displayForSimWell = true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicExportCompletionDataSettingsUi::showForWellPath()
{
m_displayForSimWell = false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -66,3 +82,25 @@ QList<caf::PdmOptionItemInfo> RicExportCompletionDataSettingsUi::calculateValueO
}
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicExportCompletionDataSettingsUi::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
uiOrdering.add(&fileName);
uiOrdering.add(&caseToApply);
uiOrdering.add(&timeStep);
uiOrdering.add(&computeTransmissibility);
uiOrdering.add(&includeWpimult);
if (!m_displayForSimWell)
{
uiOrdering.add(&includePerforations);
uiOrdering.add(&includeFishbones);
uiOrdering.add(&includeFractures);
uiOrdering.add(&removeLateralsInMainBoreCells);
}
uiOrdering.skipRemainingFields();
}

7
ApplicationCode/Commands/CompletionCommands/RicExportCompletionDataSettingsUi.h
View File

@ -43,6 +43,13 @@ public:
caf::PdmField<int> timeStep;
void showForSimWells();
void showForWellPath();
protected:
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
private:
bool m_displayForSimWell;
};

78
ApplicationCode/Commands/CompletionCommands/RicExportFractureCompletionsImpl.cpp
View File

@ -18,25 +18,34 @@
#include "RicExportFractureCompletionsImpl.h"
#include <vector>
#include "RimEclipseCase.h"
#include "RicExportCompletionDataSettingsUi.h"
#include "RimEclipseCase.h"
#include "RimFracture.h"
#include "RimWellPath.h"
#include "RimFractureTemplate.h"
#include "RimEclipseWell.h"
#include "RimSimWellFractureCollection.h"
#include "RimSimWellFracture.h"
#include "RigEclipseCaseData.h"
#include "RigTransmissibilityCondenser.h"
#include "RigFractureCell.h"
#include "RigFractureGrid.h"
#include "RimFractureTemplate.h"
#include "RigEclipseToStimPlanCellTransmissibilityCalculator.h"
#include "RigFractureTransmissibilityEquations.h"
#include "RigWellPathStimplanIntersector.h"
#include "RigMainGrid.h"
#include "RigSingleWellResultsData.h"
#include "RigSimulationWellCoordsAndMD.h"
#include "RigWellPath.h"
#include <vector>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFracturesCompdatValues(const RimWellPath* wellPath,
std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdatValuesForWellPath(const RimWellPath* wellPath,
const RicExportCompletionDataSettingsUi& settings,
QTextStream* outputStreamForIntermediateResultsText)
{
@ -45,6 +54,60 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
std::vector<RimFracture*> fracturesAlongWellPath;
wellPath->descendantsIncludingThisOfType(fracturesAlongWellPath);
return generateCompdatValues(caseToApply,
wellPath->name(),
wellPath->wellPathGeometry(),
fracturesAlongWellPath,
outputStreamForIntermediateResultsText);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdatValuesForSimWell(const RimEclipseCase* eclipseCase,
const RimEclipseWell* well,
size_t timeStep,
QTextStream* outputStreamForIntermediateResultsText)
{
std::vector<RigCompletionData> completionData;
std::vector< std::vector <cvf::Vec3d> > pipeBranchesCLCoords;
std::vector< std::vector <RigWellResultPoint> > pipeBranchesCellIds;
well->calculateWellPipeDynamicCenterLine(timeStep, pipeBranchesCLCoords, pipeBranchesCellIds);
for (size_t branchIndex = 0; branchIndex < pipeBranchesCLCoords.size(); ++branchIndex)
{
RigSimulationWellCoordsAndMD coordsAndMD(pipeBranchesCLCoords[branchIndex]);
RigWellPath wellPathGeometry;
wellPathGeometry.m_wellPathPoints = coordsAndMD.wellPathPoints();
wellPathGeometry.m_measuredDepths = coordsAndMD.measuredDepths();
std::vector<RimFracture*> fractures;
for (RimSimWellFracture* fracture : well->simwellFractureCollection->simwellFractures())
{
if (static_cast<size_t>(fracture->branchIndex()) == branchIndex)
{
fractures.push_back(fracture);
}
}
std::vector<RigCompletionData> branchCompletions = generateCompdatValues(eclipseCase, well->name(), &wellPathGeometry, fractures, outputStreamForIntermediateResultsText);
completionData.insert(completionData.end(), branchCompletions.begin(), branchCompletions.end());
}
return completionData;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdatValues(const RimEclipseCase* caseToApply,
const QString& wellPathName,
const RigWellPath* wellPathGeometry,
const std::vector<RimFracture*> fractures,
QTextStream* outputStreamForIntermediateResultsText)
{
double cDarcyInCorrectUnit = caseToApply->eclipseCaseData()->darchysValue();
const RigMainGrid* mainGrid = caseToApply->eclipseCaseData()->mainGrid();
@ -54,7 +117,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
std::map <size_t, std::map<RimFracture*, double> > eclCellIdxToTransPrFractureMap;
std::vector<RigCompletionData> fractureCompletions;
for (RimFracture* fracture : fracturesAlongWellPath)
for (RimFracture* fracture : fractures)
{
bool fractureFiniteCond = (fracture->fractureTemplate()->conductivityType() == RimFractureTemplate::FINITE_CONDUCTIVITY);
@ -193,7 +256,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
//If fracture has orientation along well, linear inflow along well and radial flow at endpoints
else if (fracture->fractureTemplate()->orientationType() == RimFractureTemplate::ALONG_WELL_PATH)
{
RigWellPathStimplanIntersector wellFractureIntersector(wellPath->wellPathGeometry(), fracture);
RigWellPathStimplanIntersector wellFractureIntersector(wellPathGeometry, fracture);
const std::map<size_t, RigWellPathStimplanIntersector::WellCellIntersection >& fractureWellCells = wellFractureIntersector.intersections();
for (const auto& fracCellIdxIsectDataPair : fractureWellCells)
@ -250,7 +313,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
size_t i, j, k;
mainGrid->ijkFromCellIndex(externalCell.m_globalCellIdx, &i, &j, &k);
RigCompletionData compDat(wellPath->name(), {i,j,k} );
RigCompletionData compDat(wellPathName, {i,j,k} );
compDat.setFromFracture(trans, fracture->fractureTemplate()->skinFactor());
compDat.addMetadata(fracture->name(), QString::number(trans));
fractureCompletions.push_back(compDat);
@ -268,7 +331,6 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
}
return fractureCompletions;
}

18
ApplicationCode/Commands/CompletionCommands/RicExportFractureCompletionsImpl.h
View File

@ -21,13 +21,29 @@ class RicExportCompletionDataSettingsUi;
#include <vector>
#include "RigCompletionData.h"
class QTextStream;
class RigWellPath;
class RimEclipseCase;
class RimEclipseWell;
class RimFracture;
class RicExportFractureCompletionsImpl
{
public:
static std::vector<RigCompletionData> generateFracturesCompdatValues(const RimWellPath* wellPath,
static std::vector<RigCompletionData> generateCompdatValuesForWellPath(const RimWellPath* wellPath,
const RicExportCompletionDataSettingsUi& settings,
QTextStream* outputStreamForIntermediateResultsText);
static std::vector<RigCompletionData> generateCompdatValuesForSimWell(const RimEclipseCase* eclipseCase,
const RimEclipseWell* well,
size_t timeStep,
QTextStream* outputStreamForIntermediateResultsText);
private:
static std::vector<RigCompletionData> generateCompdatValues(const RimEclipseCase* caseToApply,
const QString& wellPathName,
const RigWellPath* wellPathGeometry,
const std::vector<RimFracture*> fractures,
QTextStream* outputStreamForIntermediateResultsText);
};

90
ApplicationCode/Commands/CompletionCommands/RicWellPathExportCompletionDataFeature.cpp
View File

@ -31,6 +31,8 @@
#include "RimPerforationInterval.h"
#include "RimPerforationCollection.h"
#include "RimReservoirCellResultsStorage.h"
#include "RimEclipseWell.h"
#include "RimEclipseWellCollection.h"
#include "RicExportCompletionDataSettingsUi.h"
@ -61,7 +63,32 @@ CAF_CMD_SOURCE_INIT(RicWellPathExportCompletionDataFeature, "RicWellPathExportCo
//--------------------------------------------------------------------------------------------------
bool RicWellPathExportCompletionDataFeature::isCommandEnabled()
{
return !selectedWellPaths().empty();
std::vector<RimWellPath*> wellPaths = selectedWellPaths();
std::vector<RimEclipseWell*> simWells = selectedSimWells();
if (wellPaths.empty() && simWells.empty())
{
return false;
}
if (!wellPaths.empty() && !simWells.empty())
{
return false;
}
std::set<RimEclipseCase*> eclipseCases;
for (auto simWell : simWells)
{
RimEclipseCase* eclipseCase;
simWell->firstAncestorOrThisOfType(eclipseCase);
eclipseCases.insert(eclipseCase);
}
if (eclipseCases.size() > 1)
{
return false;
}
return true;
}
//--------------------------------------------------------------------------------------------------
@ -70,8 +97,9 @@ bool RicWellPathExportCompletionDataFeature::isCommandEnabled()
void RicWellPathExportCompletionDataFeature::onActionTriggered(bool isChecked)
{
std::vector<RimWellPath*> wellPaths = selectedWellPaths();
std::vector<RimEclipseWell*> simWells = selectedSimWells();
CVF_ASSERT(wellPaths.size() > 0);
CVF_ASSERT(wellPaths.size() > 0 || simWells.size() > 0);
RiaApplication* app = RiaApplication::instance();
@ -79,6 +107,16 @@ void RicWellPathExportCompletionDataFeature::onActionTriggered(bool isChecked)
QString defaultDir = RiaApplication::instance()->lastUsedDialogDirectoryWithFallback("COMPLETIONS", projectFolder);
RicExportCompletionDataSettingsUi exportSettings;
if (wellPaths.empty())
{
exportSettings.showForSimWells();
}
else
{
exportSettings.showForWellPath();
}
std::vector<RimCase*> cases;
app->project()->allCases(cases);
for (auto c : cases)
@ -98,7 +136,7 @@ void RicWellPathExportCompletionDataFeature::onActionTriggered(bool isChecked)
{
RiaApplication::instance()->setLastUsedDialogDirectory("COMPLETIONS", QFileInfo(exportSettings.fileName).absolutePath());
exportCompletions(wellPaths, exportSettings);
exportCompletions(wellPaths, simWells, exportSettings);
}
}
@ -137,7 +175,32 @@ std::vector<RimWellPath*> RicWellPathExportCompletionDataFeature::selectedWellPa
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector<RimWellPath*>& wellPaths, const RicExportCompletionDataSettingsUi& exportSettings)
std::vector<RimEclipseWell*> RicWellPathExportCompletionDataFeature::selectedSimWells()
{
std::vector<RimEclipseWell*> simWells;
caf::SelectionManager::instance()->objectsByType(&simWells);
std::vector<RimEclipseWellCollection*> simWellCollections;
caf::SelectionManager::instance()->objectsByType(&simWellCollections);
for (auto simWellCollection : simWellCollections)
{
for (auto simWell : simWellCollection->wells())
{
simWells.push_back(simWell);
}
}
std::set<RimEclipseWell*> uniqueSimWells(simWells.begin(), simWells.end());
simWells.assign(uniqueSimWells.begin(), uniqueSimWells.end());
return simWells;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector<RimWellPath*>& wellPaths, const std::vector<RimEclipseWell*>& simWells, const RicExportCompletionDataSettingsUi& exportSettings)
{
QFile exportFile(exportSettings.fileName());
@ -168,6 +231,16 @@ void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector
break;
}
}
for (const RimEclipseWell* simWell : simWells)
{
RimEclipseCase* eclipseCase;
simWell->firstAncestorOrThisOfType(eclipseCase);
if (exportSettings.caseToApply->eclipseCaseData()->unitsType() != eclipseCase->eclipseCaseData()->unitsType())
{
unitSystemMismatch = true;
break;
}
}
if (unitSystemMismatch)
{
RiaLogging::error("Well path unit systems must match unit system of chosen eclipse case.");
@ -199,13 +272,18 @@ void RicWellPathExportCompletionDataFeature::exportCompletions(const std::vector
if (exportSettings.includeFractures())
{
std::vector<RigCompletionData> fractureCompletionData =
RicExportFractureCompletionsImpl::generateFracturesCompdatValues(wellPath, exportSettings, &stream);
std::vector<RigCompletionData> fractureCompletionData = RicExportFractureCompletionsImpl::generateCompdatValuesForWellPath(wellPath, exportSettings, &stream);
appendCompletionData(&completionData, fractureCompletionData);
}
}
for (auto simWell : simWells)
{
std::vector<RigCompletionData> fractureCompletionData = RicExportFractureCompletionsImpl::generateCompdatValuesForSimWell(exportSettings.caseToApply(), simWell, exportSettings.timeStep(), &stream);
appendCompletionData(&completionData, fractureCompletionData);
}
// Merge map into a vector of values
std::vector<RigCompletionData> completions;
for (auto& data : completionData)

4
ApplicationCode/Commands/CompletionCommands/RicWellPathExportCompletionDataFeature.h
View File

@ -33,6 +33,7 @@
class RimWellPath;
class RimEclipseCase;
class RimEclipseWell;
class RigEclipseCaseData;
class RigMainGrid;
class RigCell;
@ -126,13 +127,14 @@ protected:
virtual void setupActionLook(QAction* actionToSetup) override;
std::vector<RimWellPath*> selectedWellPaths();
std::vector<RimEclipseWell*> selectedSimWells();
public:
static std::vector<WellSegmentLocation> findWellSegmentLocations(const RimEclipseCase* caseToApply, const RimWellPath* wellPath);
static std::vector<WellSegmentLocation> findWellSegmentLocations(const RimEclipseCase* caseToApply, const RimWellPath* wellPath, const std::vector<RimFishbonesMultipleSubs*>& fishbonesSubs);
private:
static void exportCompletions(const std::vector<RimWellPath*>& wellPaths, const RicExportCompletionDataSettingsUi& exportSettings);
static void exportCompletions(const std::vector<RimWellPath*>& wellPaths, const std::vector<RimEclipseWell*>& simWells, const RicExportCompletionDataSettingsUi& exportSettings);
static void generateCompdatTable(RifEclipseDataTableFormatter& formatter, const std::vector<RigCompletionData>& completionData);
static void generateWpimultTable(RifEclipseDataTableFormatter& formatter, const std::vector<RigCompletionData>& completionData);

1
ApplicationCode/ProjectDataModel/Completions/RimSimWellFracture.h
View File

@ -47,6 +47,7 @@ public:
double wellAzimuthAtFracturePosition() override;
double wellDipAtFracturePosition();
int branchIndex() const { return m_branchIndex(); }
protected:
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;

2
ApplicationCode/ProjectDataModel/RimEclipseWell.cpp
View File

@ -166,7 +166,7 @@ void RimEclipseWell::calculateWellPipeStaticCenterLine(std::vector< std::vector
//--------------------------------------------------------------------------------------------------
void RimEclipseWell::calculateWellPipeDynamicCenterLine(size_t timeStepIdx,
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds)
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) const
{
RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(this, timeStepIdx, pipeBranchesCLCoords, pipeBranchesCellIds);
}

2
ApplicationCode/ProjectDataModel/RimEclipseWell.h
View File

@ -70,7 +70,7 @@ public:
void calculateWellPipeDynamicCenterLine(size_t timeStepIdx,
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds);
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) const;
void wellHeadTopBottomPosition(size_t frameIndex, cvf::Vec3d* top, cvf::Vec3d* bottom);
double pipeRadius();

4
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp
View File

@ -45,14 +45,14 @@ void RigSimulationWellCenterLineCalculator::calculateWellPipeStaticCenterline(Ri
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(RimEclipseWell* rimWell,
void RigSimulationWellCenterLineCalculator::calculateWellPipeDynamicCenterline(const RimEclipseWell* rimWell,
size_t timeStepIndex,
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds)
{
CVF_ASSERT(rimWell);
RigSingleWellResultsData* wellResults = rimWell->wellResults();
const RigSingleWellResultsData* wellResults = rimWell->wellResults();
RimEclipseView* eclipseView;
rimWell->firstAncestorOrThisOfType(eclipseView);

2
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.h
View File

@ -32,7 +32,7 @@ public:
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) ;
static void calculateWellPipeDynamicCenterline(RimEclipseWell* rimWell,
static void calculateWellPipeDynamicCenterline(const RimEclipseWell* rimWell,
size_t timeStepIndex,
std::vector< std::vector <cvf::Vec3d> >& pipeBranchesCLCoords,
std::vector< std::vector <RigWellResultPoint> >& pipeBranchesCellIds) ;