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

#3851 Just one ICV per completion, not one per segment.

Browse Source
This commit is contained in:
Gaute Lindkvist 2018-12-17 10:06:38 +01:00
parent fff70bb9f6
commit a9f70a13b3
9 changed files with 362 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
ApplicationCode/Commands/CompletionExportCommands/RicMswCompletions.cpp
View File

@ -137,17 +137,25 @@ RigCompletionData::CompletionType RicMswPerforation::completionType() const
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RicMswValve::RicMswValve(const QString& label, RicMswValve::RicMswValve(const QString& label,
size_t index /*= cvf::UNDEFINED_SIZE_T*/, const RimWellPathValve* wellPathValve)
int branchNumber /*= cvf::UNDEFINED_INT*/) : RicMswCompletion(label)
: RicMswCompletion(label, index, branchNumber) , m_wellPathValve(wellPathValve)
{ {
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RicMswICD::RicMswICD(const QString& label, size_t index /*= cvf::UNDEFINED_SIZE_T*/, int branchNumber /*= cvf::UNDEFINED_INT*/) const RimWellPathValve* RicMswValve::wellPathValve() const
: RicMswValve(label, index, branchNumber) {
return m_wellPathValve;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicMswWsegValve::RicMswWsegValve(const QString& label, const RimWellPathValve* wellPathValve)
: RicMswValve(label, wellPathValve)
, m_flowCoefficient(0.0) , m_flowCoefficient(0.0)
, m_area(0.0) , m_area(0.0)
{ {
@ -156,7 +164,7 @@ RicMswICD::RicMswICD(const QString& label, size_t index /*= cvf::UNDEFINED_SIZE_
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RicMswICD::flowCoefficient() const double RicMswWsegValve::flowCoefficient() const
{ {
return m_flowCoefficient; return m_flowCoefficient;
} }
@ -164,7 +172,7 @@ double RicMswICD::flowCoefficient() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RicMswICD::area() const double RicMswWsegValve::area() const
{ {
return m_area; return m_area;
} }
@ -172,7 +180,7 @@ double RicMswICD::area() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicMswICD::setFlowCoefficient(double icdFlowCoefficient) void RicMswWsegValve::setFlowCoefficient(double icdFlowCoefficient)
{ {
m_flowCoefficient = icdFlowCoefficient; m_flowCoefficient = icdFlowCoefficient;
} }
@ -180,7 +188,7 @@ void RicMswICD::setFlowCoefficient(double icdFlowCoefficient)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicMswICD::setArea(double icdArea) void RicMswWsegValve::setArea(double icdArea)
{ {
m_area = icdArea; m_area = icdArea;
} }
@ -188,10 +196,8 @@ void RicMswICD::setArea(double icdArea)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RicMswFishbonesICD::RicMswFishbonesICD(const QString& label, RicMswFishbonesICD::RicMswFishbonesICD(const QString& label, const RimWellPathValve* wellPathValve)
size_t index /*= cvf::UNDEFINED_SIZE_T*/, : RicMswWsegValve(label, wellPathValve)
int branchNumber /*= cvf::UNDEFINED_INT*/)
: RicMswICD(label, index, branchNumber)
{ {
} }
@ -207,9 +213,8 @@ RigCompletionData::CompletionType RicMswFishbonesICD::completionType() const
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RicMswPerforationICD::RicMswPerforationICD(const QString& label, RicMswPerforationICD::RicMswPerforationICD(const QString& label,
size_t index /*= cvf::UNDEFINED_SIZE_T*/, const RimWellPathValve* wellPathValve)
int branchNumber /*= cvf::UNDEFINED_INT*/) : RicMswWsegValve(label, wellPathValve)
: RicMswICD(label, index, branchNumber)
{ {
} }
@ -221,13 +226,29 @@ RigCompletionData::CompletionType RicMswPerforationICD::completionType() const
return RigCompletionData::PERFORATION_ICD; return RigCompletionData::PERFORATION_ICD;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicMswPerforationICV::RicMswPerforationICV(const QString& label,
const RimWellPathValve* wellPathValve)
: RicMswWsegValve(label, wellPathValve)
{
}
//-------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigCompletionData::CompletionType RicMswPerforationICV::completionType() const
{
return RigCompletionData::PERFORATION_ICV;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RicMswPerforationAICD::RicMswPerforationAICD(const QString& label, RicMswPerforationAICD::RicMswPerforationAICD(const QString& label,
size_t index /*= cvf::UNDEFINED_SIZE_T*/, const RimWellPathValve* wellPathValve)
int branchNumber /*= cvf::UNDEFINED_INT*/) : RicMswValve(label, wellPathValve)
: RicMswValve(label, index, branchNumber), m_valid(false), m_deviceOpen(false)
{ {
} }

33
ApplicationCode/Commands/CompletionExportCommands/RicMswCompletions.h
View File

@ -97,17 +97,24 @@ public:
class RicMswValve : public RicMswCompletion class RicMswValve : public RicMswCompletion
{ {
public: public:
RicMswValve(const QString& label, size_t index = cvf::UNDEFINED_SIZE_T, int branchNumber = cvf::UNDEFINED_INT); RicMswValve(const QString& label, const RimWellPathValve* wellPathValve);
virtual ~RicMswValve() {} virtual ~RicMswValve() {}
const RimWellPathValve* wellPathValve() const;
private:
const RimWellPathValve* m_wellPathValve;
}; };
//================================================================================================== //==================================================================================================
/// ///
//================================================================================================== //==================================================================================================
class RicMswICD : public RicMswValve class RicMswWsegValve : public RicMswValve
{ {
public: public:
RicMswICD(const QString& label, size_t index = cvf::UNDEFINED_SIZE_T, int branchNumber = cvf::UNDEFINED_INT); RicMswWsegValve(const QString& label, const RimWellPathValve* wellPathValve);
double flowCoefficient() const; double flowCoefficient() const;
double area() const; double area() const;
void setFlowCoefficient(double icdFlowCoefficient); void setFlowCoefficient(double icdFlowCoefficient);
@ -120,20 +127,30 @@ private:
//================================================================================================== //==================================================================================================
/// ///
//================================================================================================== //==================================================================================================
class RicMswFishbonesICD : public RicMswICD class RicMswFishbonesICD : public RicMswWsegValve
{ {
public: public:
RicMswFishbonesICD(const QString& label, size_t index = cvf::UNDEFINED_SIZE_T, int branchNumber = cvf::UNDEFINED_INT); RicMswFishbonesICD(const QString& label, const RimWellPathValve* wellPathValve);
RigCompletionData::CompletionType completionType() const override; RigCompletionData::CompletionType completionType() const override;
}; };
//================================================================================================== //==================================================================================================
/// ///
//================================================================================================== //==================================================================================================
class RicMswPerforationICD : public RicMswICD class RicMswPerforationICD : public RicMswWsegValve
{ {
public: public:
RicMswPerforationICD(const QString& label, size_t index = cvf::UNDEFINED_SIZE_T, int branchNumber = cvf::UNDEFINED_INT); RicMswPerforationICD(const QString& label, const RimWellPathValve* wellPathValve);
RigCompletionData::CompletionType completionType() const override;
};
//==================================================================================================
///
//==================================================================================================
class RicMswPerforationICV : public RicMswWsegValve
{
public:
RicMswPerforationICV(const QString& label, const RimWellPathValve* wellPathValve);
RigCompletionData::CompletionType completionType() const override; RigCompletionData::CompletionType completionType() const override;
}; };
@ -143,7 +160,7 @@ public:
class RicMswPerforationAICD : public RicMswValve class RicMswPerforationAICD : public RicMswValve
{ {
public: public:
RicMswPerforationAICD(const QString& label, size_t index = cvf::UNDEFINED_SIZE_T, int branchNumber = cvf::UNDEFINED_INT); RicMswPerforationAICD(const QString& label, const RimWellPathValve* wellPathValve);
RigCompletionData::CompletionType completionType() const override; RigCompletionData::CompletionType completionType() const override;
bool isValid() const; bool isValid() const;

16
ApplicationCode/Commands/CompletionExportCommands/RicMswSegment.cpp
View File

@ -223,6 +223,21 @@ void RicMswSegment::addCompletion(std::shared_ptr<RicMswCompletion> completion)
m_completions.push_back(completion); m_completions.push_back(completion);
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicMswSegment::removeCompletion(std::shared_ptr<RicMswCompletion> completion)
{
for (auto it = m_completions.begin(); it != m_completions.end(); ++it)
{
if ((*it) == completion)
{
m_completions.erase(it);
break;
}
}
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -247,4 +262,3 @@ bool RicMswSegment::operator<(const RicMswSegment& rhs) const
return startMD() < rhs.startMD(); return startMD() < rhs.startMD();
} }

1
ApplicationCode/Commands/CompletionExportCommands/RicMswSegment.h
View File

@ -64,6 +64,7 @@ public:
void setSkinFactor(double skinFactor); void setSkinFactor(double skinFactor);
void setSegmentNumber(int segmentNumber); void setSegmentNumber(int segmentNumber);
void addCompletion(std::shared_ptr<RicMswCompletion> completion); void addCompletion(std::shared_ptr<RicMswCompletion> completion);
void removeCompletion(std::shared_ptr<RicMswCompletion> completion);
void setSourcePdmObject(const caf::PdmObject* object); void setSourcePdmObject(const caf::PdmObject* object);
const caf::PdmObject* sourcePdmObject() const; const caf::PdmObject* sourcePdmObject() const;

2
ApplicationCode/Commands/CompletionExportCommands/RicMswValveAccumulators.cpp
View File

@ -56,7 +56,7 @@ bool RicMswICDAccumulator::accumulateValveParameters(const RimWellPathValve* wel
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicMswICDAccumulator::applyToSuperValve(std::shared_ptr<RicMswValve> valve) void RicMswICDAccumulator::applyToSuperValve(std::shared_ptr<RicMswValve> valve)
{ {
std::shared_ptr<RicMswICD> icd = std::dynamic_pointer_cast<RicMswICD>(valve); std::shared_ptr<RicMswWsegValve> icd = std::dynamic_pointer_cast<RicMswWsegValve>(valve);
CVF_ASSERT(icd); CVF_ASSERT(icd);
icd->setArea(m_areaSum); icd->setArea(m_areaSum);
if (m_coefficientCalculator.validAggregatedWeight()) if (m_coefficientCalculator.validAggregatedWeight())

279
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportMswCompletionsImpl.cpp
View File

@ -82,7 +82,8 @@ public:
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions(const RicExportCompletionDataSettingsUi& exportSettings, void RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions(
const RicExportCompletionDataSettingsUi& exportSettings,
const std::vector<RimWellPath*>& wellPaths) const std::vector<RimWellPath*>& wellPaths)
{ {
std::shared_ptr<QFile> unifiedExportFile; std::shared_ptr<QFile> unifiedExportFile;
@ -99,9 +100,11 @@ void RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions(co
bool exportFractures = exportSettings.includeFractures() && !wellPath->fractureCollection()->activeFractures().empty(); bool exportFractures = exportSettings.includeFractures() && !wellPath->fractureCollection()->activeFractures().empty();
bool exportPerforations = bool exportPerforations =
exportSettings.includePerforations() && !wellPath->perforationIntervalCollection()->activePerforations().empty(); exportSettings.includePerforations() && !wellPath->perforationIntervalCollection()->activePerforations().empty();
bool exportFishbones = exportSettings.includeFishbones() && !wellPath->fishbonesCollection()->activeFishbonesSubs().empty(); bool exportFishbones =
exportSettings.includeFishbones() && !wellPath->fishbonesCollection()->activeFishbonesSubs().empty();
bool exportAnyCompletion = exportFractures || exportPerforations || exportFishbones; bool exportAnyCompletion = exportFractures || exportPerforations || exportFishbones;
if (exportAnyCompletion && exportSettings.fileSplit() == RicExportCompletionDataSettingsUi::SPLIT_ON_WELL && !unifiedWellPathFile) if (exportAnyCompletion && exportSettings.fileSplit() == RicExportCompletionDataSettingsUi::SPLIT_ON_WELL &&
!unifiedWellPathFile)
{ {
QString wellFileName = QString wellFileName =
QString("%1_UnifiedCompletions_MSW_%2") QString("%1_UnifiedCompletions_MSW_%2")
@ -123,7 +126,8 @@ void RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions(co
.arg(wellPath->completions()->wellNameForExport(), exportSettings.caseToApply->caseUserDescription()); .arg(wellPath->completions()->wellNameForExport(), exportSettings.caseToApply->caseUserDescription());
fractureExportFile = RicWellPathExportCompletionsFileTools::openFileForExport(exportSettings.folder, fileName); fractureExportFile = RicWellPathExportCompletionsFileTools::openFileForExport(exportSettings.folder, fileName);
} }
exportWellSegmentsForFractures(exportSettings.caseToApply, fractureExportFile, wellPath, wellPath->fractureCollection()->activeFractures()); exportWellSegmentsForFractures(
exportSettings.caseToApply, fractureExportFile, wellPath, wellPath->fractureCollection()->activeFractures());
} }
if (exportPerforations) if (exportPerforations)
@ -138,10 +142,14 @@ void RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions(co
QString fileName = QString fileName =
QString("%1_Perforation_MSW_%2") QString("%1_Perforation_MSW_%2")
.arg(wellPath->completions()->wellNameForExport(), exportSettings.caseToApply->caseUserDescription()); .arg(wellPath->completions()->wellNameForExport(), exportSettings.caseToApply->caseUserDescription());
perforationsExportFile = RicWellPathExportCompletionsFileTools::openFileForExport(exportSettings.folder, fileName); perforationsExportFile =
RicWellPathExportCompletionsFileTools::openFileForExport(exportSettings.folder, fileName);
} }
exportWellSegmentsForPerforations( exportWellSegmentsForPerforations(exportSettings.caseToApply,
exportSettings.caseToApply, perforationsExportFile, wellPath, exportSettings.timeStep, wellPath->perforationIntervalCollection()->activePerforations()); perforationsExportFile,
wellPath,
exportSettings.timeStep,
wellPath->perforationIntervalCollection()->activePerforations());
} }
if (exportFishbones) if (exportFishbones)
@ -156,8 +164,7 @@ void RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions(co
QString fileName = QString fileName =
QString("%1_Fishbones_MSW_%2") QString("%1_Fishbones_MSW_%2")
.arg(wellPath->completions()->wellNameForExport(), exportSettings.caseToApply->caseUserDescription()); .arg(wellPath->completions()->wellNameForExport(), exportSettings.caseToApply->caseUserDescription());
fishbonesExportFile = fishbonesExportFile = RicWellPathExportCompletionsFileTools::openFileForExport(exportSettings.folder, fileName);
RicWellPathExportCompletionsFileTools::openFileForExport(exportSettings.folder, fileName);
} }
exportWellSegmentsForFishbones(exportSettings.caseToApply, exportWellSegmentsForFishbones(exportSettings.caseToApply,
fishbonesExportFile, fishbonesExportFile,
@ -165,7 +172,6 @@ void RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions(co
wellPath->fishbonesCollection()->activeFishbonesSubs()); wellPath->fishbonesCollection()->activeFishbonesSubs());
} }
} }
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -231,8 +237,7 @@ void RicWellPathExportMswCompletionsImpl::exportWellSegmentsForPerforations(
return; return;
} }
RicMswExportInfo exportInfo = generatePerforationsMswExportInfo( RicMswExportInfo exportInfo = generatePerforationsMswExportInfo(eclipseCase, wellPath, timeStep, perforationIntervals);
eclipseCase, wellPath, timeStep, perforationIntervals);
QTextStream stream(exportFile.get()); QTextStream stream(exportFile.get());
RifEclipseDataTableFormatter formatter(stream); RifEclipseDataTableFormatter formatter(stream);
@ -331,7 +336,10 @@ void RicWellPathExportMswCompletionsImpl::generateWelsegsTable(RifEclipseDataTab
{ {
generateWelsegsSegments(formatter, exportInfo, {RigCompletionData::FISHBONES_ICD, RigCompletionData::FISHBONES}); generateWelsegsSegments(formatter, exportInfo, {RigCompletionData::FISHBONES_ICD, RigCompletionData::FISHBONES});
generateWelsegsSegments(formatter, exportInfo, {RigCompletionData::FRACTURE}); generateWelsegsSegments(formatter, exportInfo, {RigCompletionData::FRACTURE});
generateWelsegsSegments(formatter, exportInfo, {RigCompletionData::PERFORATION_ICD, RigCompletionData::PERFORATION_AICD}); generateWelsegsSegments(
formatter,
exportInfo,
{RigCompletionData::PERFORATION_ICD, RigCompletionData::PERFORATION_ICV, RigCompletionData::PERFORATION_AICD});
} }
formatter.tableCompleted(); formatter.tableCompleted();
@ -358,9 +366,7 @@ void RicWellPathExportMswCompletionsImpl::generateWelsegsSegments(
generatedHeader = true; generatedHeader = true;
} }
if (completion->completionType() == RigCompletionData::FISHBONES_ICD || if (RigCompletionData::isValve(completion->completionType()))
completion->completionType() == RigCompletionData::PERFORATION_ICD ||
completion->completionType() == RigCompletionData::PERFORATION_AICD) // Found ICD
{ {
if (!completion->subSegments().empty()) if (!completion->subSegments().empty())
{ {
@ -439,7 +445,7 @@ void RicWellPathExportMswCompletionsImpl::generateWelsegsCompletionCommentHeader
formatter.comment("Diam: MSW - Tubing Radius"); formatter.comment("Diam: MSW - Tubing Radius");
formatter.comment("Rough: MSW - Open Hole Roughness Factor"); formatter.comment("Rough: MSW - Open Hole Roughness Factor");
} }
else if (completionType == RigCompletionData::PERFORATION_ICD || completionType == RigCompletionData::PERFORATION_AICD) else if (RigCompletionData::isPerforationValve(completionType))
{ {
formatter.comment("Perforation Valve Segments"); formatter.comment("Perforation Valve Segments");
formatter.comment("Diam: MSW - Tubing Radius"); formatter.comment("Diam: MSW - Tubing Radius");
@ -486,7 +492,8 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegTables(RifEclipseDataTa
{ {
std::set<RigCompletionData::CompletionType> perforationTypes = {RigCompletionData::PERFORATION, std::set<RigCompletionData::CompletionType> perforationTypes = {RigCompletionData::PERFORATION,
RigCompletionData::PERFORATION_ICD, RigCompletionData::PERFORATION_ICD,
RigCompletionData::PERFORATION_AICD }; RigCompletionData::PERFORATION_ICV,
RigCompletionData::PERFORATION_AICD};
generateCompsegTable(formatter, exportInfo, false, perforationTypes); generateCompsegTable(formatter, exportInfo, false, perforationTypes);
if (exportInfo.hasSubGridIntersections()) if (exportInfo.hasSubGridIntersections())
{ {
@ -541,8 +548,7 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegTable(
formatter.add(completion->branchNumber()); formatter.add(completion->branchNumber());
double startLength = subSegment->startMD(); double startLength = subSegment->startMD();
if (exportInfo.lengthAndDepthText() == QString("INC") && if (exportInfo.lengthAndDepthText() == QString("INC") && completion->branchNumber() != 1)
completion->branchNumber() != 1)
{ {
startLength -= startMD; startLength -= startMD;
} }
@ -628,8 +634,7 @@ void RicWellPathExportMswCompletionsImpl::generateWsegvalvTable(RifEclipseDataTa
{ {
for (std::shared_ptr<RicMswCompletion> completion : location->completions()) for (std::shared_ptr<RicMswCompletion> completion : location->completions())
{ {
if (completion->completionType() == RigCompletionData::FISHBONES_ICD || if (RigCompletionData::isWsegValveTypes(completion->completionType()))
completion->completionType() == RigCompletionData::PERFORATION_ICD)
{ {
if (!foundValve) if (!foundValve)
{ {
@ -644,14 +649,13 @@ void RicWellPathExportMswCompletionsImpl::generateWsegvalvTable(RifEclipseDataTa
foundValve = true; foundValve = true;
} }
if (completion->completionType() == RigCompletionData::FISHBONES_ICD ||
completion->completionType() == RigCompletionData::PERFORATION_ICD) std::shared_ptr<RicMswWsegValve> icd = std::static_pointer_cast<RicMswWsegValve>(completion);
{
std::shared_ptr<RicMswICD> icd = std::static_pointer_cast<RicMswICD>(completion);
if (!icd->subSegments().empty()) if (!icd->subSegments().empty())
{ {
CVF_ASSERT(icd->subSegments().size() == 1u); CVF_ASSERT(icd->subSegments().size() == 1u);
if (icd->completionType() == RigCompletionData::PERFORATION_ICD) if (icd->completionType() == RigCompletionData::PERFORATION_ICD ||
icd->completionType() == RigCompletionData::PERFORATION_ICV)
{ {
formatter.comment(icd->label()); formatter.comment(icd->label());
} }
@ -664,7 +668,6 @@ void RicWellPathExportMswCompletionsImpl::generateWsegvalvTable(RifEclipseDataTa
} }
} }
} }
}
if (foundValve) if (foundValve)
{ {
formatter.tableCompleted(); formatter.tableCompleted();
@ -693,15 +696,21 @@ void RicWellPathExportMswCompletionsImpl::generateWsegAicdTable(RifEclipseDataTa
std::shared_ptr<RicMswPerforationAICD> aicd = std::static_pointer_cast<RicMswPerforationAICD>(completion); std::shared_ptr<RicMswPerforationAICD> aicd = std::static_pointer_cast<RicMswPerforationAICD>(completion);
if (!aicd->isValid()) if (!aicd->isValid())
{ {
RiaLogging::error(QString("Export AICD Valve (%1): Valve is invalid. At least one required template parameter is not set.").arg(aicd->label())); RiaLogging::error(
QString("Export AICD Valve (%1): Valve is invalid. At least one required template parameter is not set.")
.arg(aicd->label()));
} }
if (!foundValve) if (!foundValve)
{ {
std::vector<QString> columnDescriptions = std::vector<QString> columnDescriptions = {
{ "Well Name",
"Well Name", "Segment Number", "Segment Number", "Strength of AICD", "Segment Number",
"Length of AICD", "Density of Calibration Fluid", "Viscosity of Calibration Fluid", "Segment Number",
"Strength of AICD",
"Length of AICD",
"Density of Calibration Fluid",
"Viscosity of Calibration Fluid",
"Critical water in liquid fraction for emulsions viscosity model", "Critical water in liquid fraction for emulsions viscosity model",
"Emulsion viscosity transition region", "Emulsion viscosity transition region",
"Max ratio of emulsion viscosity to continuous phase viscosity", "Max ratio of emulsion viscosity to continuous phase viscosity",
@ -715,8 +724,7 @@ void RicWellPathExportMswCompletionsImpl::generateWsegAicdTable(RifEclipseDataTa
"Exponent of the gas flowing fraction in the density mixture calculation", "Exponent of the gas flowing fraction in the density mixture calculation",
"Exponent of the oil flowing fraction in the density viscosity calculation", "Exponent of the oil flowing fraction in the density viscosity calculation",
"Exponent of the water flowing fraction in the density viscosity calculation", "Exponent of the water flowing fraction in the density viscosity calculation",
"Exponent of the gas flowing fraction in the density viscosity calculation" "Exponent of the gas flowing fraction in the density viscosity calculation"};
};
formatter.keyword("WSEGAICD"); formatter.keyword("WSEGAICD");
formatter.comment("Column Overview:"); formatter.comment("Column Overview:");
@ -729,8 +737,8 @@ void RicWellPathExportMswCompletionsImpl::generateWsegAicdTable(RifEclipseDataTa
for (size_t i = 1; i <= 21; ++i) for (size_t i = 1; i <= 21; ++i)
{ {
QString cName = QString("%1").arg(i, 2, 10, QChar('0')); QString cName = QString("%1").arg(i, 2, 10, QChar('0'));
RifEclipseOutputTableColumn col(cName, RifEclipseOutputTableColumn col(
RifEclipseOutputTableDoubleFormatting(RifEclipseOutputTableDoubleFormat::RIF_CONSISE), RIGHT); cName, RifEclipseOutputTableDoubleFormatting(RifEclipseOutputTableDoubleFormat::RIF_CONSISE), RIGHT);
header.push_back(col); header.push_back(col);
} }
formatter.header(header); formatter.header(header);
@ -750,20 +758,27 @@ void RicWellPathExportMswCompletionsImpl::generateWsegAicdTable(RifEclipseDataTa
formatter.add(aicd->length()); // 5 formatter.add(aicd->length()); // 5
formatter.add(values[AICD_DENSITY_CALIB_FLUID]); formatter.add(values[AICD_DENSITY_CALIB_FLUID]);
formatter.add(values[AICD_VISCOSITY_CALIB_FLUID]); formatter.add(values[AICD_VISCOSITY_CALIB_FLUID]);
formatter.addValueOrDefaultMarker(values[AICD_CRITICAL_WATER_IN_LIQUID_FRAC], RicMswExportInfo::defaultDoubleValue()); formatter.addValueOrDefaultMarker(values[AICD_CRITICAL_WATER_IN_LIQUID_FRAC],
formatter.addValueOrDefaultMarker(values[AICD_EMULSION_VISC_TRANS_REGION], RicMswExportInfo::defaultDoubleValue()); RicMswExportInfo::defaultDoubleValue());
formatter.addValueOrDefaultMarker(values[AICD_MAX_RATIO_EMULSION_VISC], RicMswExportInfo::defaultDoubleValue()); // 10 formatter.addValueOrDefaultMarker(values[AICD_EMULSION_VISC_TRANS_REGION],
RicMswExportInfo::defaultDoubleValue());
formatter.addValueOrDefaultMarker(values[AICD_MAX_RATIO_EMULSION_VISC],
RicMswExportInfo::defaultDoubleValue()); // 10
formatter.add(1); formatter.add(1);
formatter.addValueOrDefaultMarker(values[AICD_MAX_FLOW_RATE], RicMswExportInfo::defaultDoubleValue()); formatter.addValueOrDefaultMarker(values[AICD_MAX_FLOW_RATE], RicMswExportInfo::defaultDoubleValue());
formatter.add(values[AICD_VOL_FLOW_EXP]); formatter.add(values[AICD_VOL_FLOW_EXP]);
formatter.add(values[AICD_VISOSITY_FUNC_EXP]); formatter.add(values[AICD_VISOSITY_FUNC_EXP]);
formatter.add(aicd->isOpen() ? "OPEN" : "SHUT"); // 15 formatter.add(aicd->isOpen() ? "OPEN" : "SHUT"); // 15
formatter.addValueOrDefaultMarker(values[AICD_EXP_OIL_FRAC_DENSITY], RicMswExportInfo::defaultDoubleValue()); formatter.addValueOrDefaultMarker(values[AICD_EXP_OIL_FRAC_DENSITY], RicMswExportInfo::defaultDoubleValue());
formatter.addValueOrDefaultMarker(values[AICD_EXP_WATER_FRAC_DENSITY], RicMswExportInfo::defaultDoubleValue()); formatter.addValueOrDefaultMarker(values[AICD_EXP_WATER_FRAC_DENSITY],
RicMswExportInfo::defaultDoubleValue());
formatter.addValueOrDefaultMarker(values[AICD_EXP_GAS_FRAC_DENSITY], RicMswExportInfo::defaultDoubleValue()); formatter.addValueOrDefaultMarker(values[AICD_EXP_GAS_FRAC_DENSITY], RicMswExportInfo::defaultDoubleValue());
formatter.addValueOrDefaultMarker(values[AICD_EXP_OIL_FRAC_VISCOSITY], RicMswExportInfo::defaultDoubleValue()); formatter.addValueOrDefaultMarker(values[AICD_EXP_OIL_FRAC_VISCOSITY],
formatter.addValueOrDefaultMarker(values[AICD_EXP_WATER_FRAC_VISCOSITY], RicMswExportInfo::defaultDoubleValue()); // 20 RicMswExportInfo::defaultDoubleValue());
formatter.addValueOrDefaultMarker(values[AICD_EXP_GAS_FRAC_VISCOSITY], RicMswExportInfo::defaultDoubleValue()); formatter.addValueOrDefaultMarker(values[AICD_EXP_WATER_FRAC_VISCOSITY],
RicMswExportInfo::defaultDoubleValue()); // 20
formatter.addValueOrDefaultMarker(values[AICD_EXP_GAS_FRAC_VISCOSITY],
RicMswExportInfo::defaultDoubleValue());
formatter.rowCompleted(); formatter.rowCompleted();
} }
} }
@ -839,8 +854,9 @@ RicMswExportInfo RicWellPathExportMswCompletionsImpl::generateFishbonesMswExport
if (ssi == 0) if (ssi == 0)
{ {
// Add completion for ICD // Add completion for ICD
std::shared_ptr<RicMswFishbonesICD> icdCompletion(new RicMswFishbonesICD(QString("ICD"))); std::shared_ptr<RicMswFishbonesICD> icdCompletion(new RicMswFishbonesICD(QString("ICD"), nullptr));
std::shared_ptr<RicMswSubSegment> icdSegment(new RicMswSubSegment(subEndMD, subEndMD + 0.1, subEndTVD, subEndTVD)); std::shared_ptr<RicMswSubSegment> icdSegment(
new RicMswSubSegment(subEndMD, subEndMD + 0.1, subEndTVD, subEndTVD));
icdCompletion->setFlowCoefficient(subs->icdFlowCoefficient()); icdCompletion->setFlowCoefficient(subs->icdFlowCoefficient());
double icdOrificeRadius = subs->icdOrificeDiameter(unitSystem) / 2; double icdOrificeRadius = subs->icdOrificeDiameter(unitSystem) / 2;
icdCompletion->setArea(icdOrificeRadius * icdOrificeRadius * cvf::PI_D * subs->icdCount()); icdCompletion->setArea(icdOrificeRadius * icdOrificeRadius * cvf::PI_D * subs->icdCount());
@ -1040,9 +1056,10 @@ RicMswExportInfo RicWellPathExportMswCompletionsImpl::generatePerforationsMswExp
MainBoreSegments mainBoreSegments = createMainBoreSegmentsForPerforations( MainBoreSegments mainBoreSegments = createMainBoreSegmentsForPerforations(
subSegIntersections, perforationIntervals, wellPath, timeStep, eclipseCase, &foundSubGridIntersections); subSegIntersections, perforationIntervals, wellPath, timeStep, eclipseCase, &foundSubGridIntersections);
assignSuperValveCompletions(mainBoreSegments, perforationIntervals); createValveCompletions(mainBoreSegments, perforationIntervals, unitSystem);
assignValveContributionsToSuperValves(mainBoreSegments, perforationIntervals, unitSystem); assignValveContributionsToSuperICDsOrAICDs(mainBoreSegments, perforationIntervals, unitSystem);
moveIntersectionsToSuperValves(mainBoreSegments); moveIntersectionsToICVs(mainBoreSegments, perforationIntervals, unitSystem);
moveIntersectionsToSuperICDsOrAICDs(mainBoreSegments);
for (std::shared_ptr<RicMswSegment> segment : mainBoreSegments) for (std::shared_ptr<RicMswSegment> segment : mainBoreSegments)
{ {
@ -1087,7 +1104,8 @@ RicWellPathExportMswCompletionsImpl::MainBoreSegments RicWellPathExportMswComple
std::shared_ptr<RicMswCompletion> intervalCompletion(new RicMswPerforation(interval->name())); std::shared_ptr<RicMswCompletion> intervalCompletion(new RicMswPerforation(interval->name()));
std::vector<RigCompletionData> completionData = std::vector<RigCompletionData> completionData =
generatePerforationIntersections(wellPath, interval, timeStep, eclipseCase); generatePerforationIntersections(wellPath, interval, timeStep, eclipseCase);
assignPerforationIntersections(completionData, intervalCompletion, cellIntInfo, overlapStart, overlapEnd, foundSubGridIntersections); assignPerforationIntersections(
completionData, intervalCompletion, cellIntInfo, overlapStart, overlapEnd, foundSubGridIntersections);
segment->addCompletion(intervalCompletion); segment->addCompletion(intervalCompletion);
} }
} }
@ -1100,14 +1118,16 @@ RicWellPathExportMswCompletionsImpl::MainBoreSegments RicWellPathExportMswComple
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicWellPathExportMswCompletionsImpl::assignSuperValveCompletions( void RicWellPathExportMswCompletionsImpl::createValveCompletions(
std::vector<std::shared_ptr<RicMswSegment>>& mainBoreSegments, std::vector<std::shared_ptr<RicMswSegment>>& mainBoreSegments,
const std::vector<const RimPerforationInterval*>& perforationIntervals) const std::vector<const RimPerforationInterval*>& perforationIntervals,
RiaEclipseUnitTools::UnitSystem unitSystem)
{ {
for (size_t nMainSegment = 0u; nMainSegment < mainBoreSegments.size(); ++nMainSegment) for (size_t nMainSegment = 0u; nMainSegment < mainBoreSegments.size(); ++nMainSegment)
{ {
std::shared_ptr<RicMswSegment> segment = mainBoreSegments[nMainSegment]; std::shared_ptr<RicMswSegment> segment = mainBoreSegments[nMainSegment];
std::shared_ptr<RicMswPerforationICV> ICV;
std::shared_ptr<RicMswPerforationICD> superICD; std::shared_ptr<RicMswPerforationICD> superICD;
std::shared_ptr<RicMswPerforationAICD> superAICD; std::shared_ptr<RicMswPerforationAICD> superAICD;
@ -1125,7 +1145,6 @@ void RicWellPathExportMswCompletionsImpl::assignSuperValveCompletions(
{ {
if (!valve->isChecked()) continue; if (!valve->isChecked()) continue;
bool isAicd = valve->componentType() == RiaDefines::AICD;
for (size_t nSubValve = 0u; nSubValve < valve->valveLocations().size(); ++nSubValve) for (size_t nSubValve = 0u; nSubValve < valve->valveLocations().size(); ++nSubValve)
{ {
double valveMD = valve->valveLocations()[nSubValve]; double valveMD = valve->valveLocations()[nSubValve];
@ -1136,41 +1155,57 @@ void RicWellPathExportMswCompletionsImpl::assignSuperValveCompletions(
double overlap = std::max(0.0, overlapEnd - overlapStart); double overlap = std::max(0.0, overlapEnd - overlapStart);
if (segment->startMD() <= valveMD && valveMD < segment->endMD()) if (segment->startMD() <= valveMD && valveMD < segment->endMD())
{
if (valve->componentType() == RiaDefines::AICD)
{ {
QString valveLabel = QString("%1 #%2").arg("Combined Valve for segment").arg(nMainSegment + 2); QString valveLabel = QString("%1 #%2").arg("Combined Valve for segment").arg(nMainSegment + 2);
std::shared_ptr<RicMswSubSegment> subSegment(new RicMswSubSegment(valveMD, valveMD + 0.1, 0.0, 0.0)); std::shared_ptr<RicMswSubSegment> subSegment(new RicMswSubSegment(valveMD, valveMD + 0.1, 0.0, 0.0));
if (isAicd) superAICD = std::make_shared<RicMswPerforationAICD>(valveLabel, valve);
{
superAICD = std::make_shared<RicMswPerforationAICD>(valveLabel);
superAICD->addSubSegment(subSegment); superAICD->addSubSegment(subSegment);
} }
else else if (valve->componentType() == RiaDefines::ICD)
{
superICD = std::make_shared<RicMswPerforationICD>(valveLabel);
superICD->addSubSegment(subSegment);
}
}
else if (overlap > 0.0 && (!isAicd && !superICD))
{ {
QString valveLabel = QString("%1 #%2").arg("Combined Valve for segment").arg(nMainSegment + 2); QString valveLabel = QString("%1 #%2").arg("Combined Valve for segment").arg(nMainSegment + 2);
std::shared_ptr<RicMswSubSegment> subSegment(new RicMswSubSegment(overlapStart, overlapStart + 0.1, 0.0, 0.0)); std::shared_ptr<RicMswSubSegment> subSegment(new RicMswSubSegment(valveMD, valveMD + 0.1, 0.0, 0.0));
superICD = std::make_shared<RicMswPerforationICD>(valveLabel);
superICD = std::make_shared<RicMswPerforationICD>(valveLabel, valve);
superICD->addSubSegment(subSegment); superICD->addSubSegment(subSegment);
} }
else if (overlap > 0.0 && (isAicd && !superAICD)) else if (valve->componentType() == RiaDefines::ICV)
{
QString valveLabel = QString("ICV %1 at segment #%2").arg(valve->name()).arg(nMainSegment + 2);
std::shared_ptr<RicMswSubSegment> subSegment(new RicMswSubSegment(valveMD, valveMD + 0.1, 0.0, 0.0));
ICV = std::make_shared<RicMswPerforationICV>(valveLabel, valve);
ICV->addSubSegment(subSegment);
ICV->setFlowCoefficient(valve->flowCoefficient());
double orificeRadius = valve->orificeDiameter(unitSystem) / 2;
ICV->setArea(orificeRadius * orificeRadius * cvf::PI_D);
}
}
else if (overlap > 0.0 && (valve->componentType() == RiaDefines::ICD && !superICD))
{ {
QString valveLabel = QString("%1 #%2").arg("Combined Valve for segment").arg(nMainSegment + 2); QString valveLabel = QString("%1 #%2").arg("Combined Valve for segment").arg(nMainSegment + 2);
std::shared_ptr<RicMswSubSegment> subSegment(new RicMswSubSegment(overlapStart, overlapStart + 0.1, 0.0, 0.0)); std::shared_ptr<RicMswSubSegment> subSegment(
superAICD = std::make_shared<RicMswPerforationAICD>(valveLabel); new RicMswSubSegment(overlapStart, overlapStart + 0.1, 0.0, 0.0));
superICD = std::make_shared<RicMswPerforationICD>(valveLabel, valve);
superICD->addSubSegment(subSegment);
}
else if (overlap > 0.0 && (valve->componentType() == RiaDefines::AICD && !superAICD))
{
QString valveLabel = QString("%1 #%2").arg("Combined Valve for segment").arg(nMainSegment + 2);
std::shared_ptr<RicMswSubSegment> subSegment(
new RicMswSubSegment(overlapStart, overlapStart + 0.1, 0.0, 0.0));
superAICD = std::make_shared<RicMswPerforationAICD>(valveLabel, valve);
superAICD->addSubSegment(subSegment); superAICD->addSubSegment(subSegment);
} }
if (isAicd) if (valve->componentType() == RiaDefines::AICD)
{ {
totalAICDOverlap += overlap; totalAICDOverlap += overlap;
} }
else else if (valve->componentType() == RiaDefines::ICD)
{ {
totalICDOverlap += overlap; totalICDOverlap += overlap;
} }
@ -1178,6 +1213,12 @@ void RicWellPathExportMswCompletionsImpl::assignSuperValveCompletions(
} }
} }
if (ICV)
{
segment->addCompletion(ICV);
}
else
{
if (totalICDOverlap > 0.0 || totalAICDOverlap > 0.0) if (totalICDOverlap > 0.0 || totalAICDOverlap > 0.0)
{ {
if (totalAICDOverlap > totalICDOverlap) if (totalAICDOverlap > totalICDOverlap)
@ -1190,12 +1231,13 @@ void RicWellPathExportMswCompletionsImpl::assignSuperValveCompletions(
} }
} }
} }
}
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicWellPathExportMswCompletionsImpl::assignValveContributionsToSuperValves( void RicWellPathExportMswCompletionsImpl::assignValveContributionsToSuperICDsOrAICDs(
const std::vector<std::shared_ptr<RicMswSegment>>& mainBoreSegments, const std::vector<std::shared_ptr<RicMswSegment>>& mainBoreSegments,
const std::vector<const RimPerforationInterval*>& perforationIntervals, const std::vector<const RimPerforationInterval*>& perforationIntervals,
RiaEclipseUnitTools::UnitSystem unitSystem) RiaEclipseUnitTools::UnitSystem unitSystem)
@ -1214,8 +1256,6 @@ void RicWellPathExportMswCompletionsImpl::assignValveContributionsToSuperValves(
} }
} }
if (!superValve) continue;
std::shared_ptr<RicMswValveAccumulator> accumulator; std::shared_ptr<RicMswValveAccumulator> accumulator;
if (std::dynamic_pointer_cast<const RicMswPerforationICD>(superValve)) if (std::dynamic_pointer_cast<const RicMswPerforationICD>(superValve))
{ {
@ -1226,6 +1266,8 @@ void RicWellPathExportMswCompletionsImpl::assignValveContributionsToSuperValves(
accumulator = std::make_shared<RicMswAICDAccumulator>(unitSystem); accumulator = std::make_shared<RicMswAICDAccumulator>(unitSystem);
} }
if (!accumulator) continue;
for (const RimPerforationInterval* interval : perforationIntervals) for (const RimPerforationInterval* interval : perforationIntervals)
{ {
if (!interval->isChecked()) continue; if (!interval->isChecked()) continue;
@ -1280,7 +1322,83 @@ void RicWellPathExportMswCompletionsImpl::assignValveContributionsToSuperValves(
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicWellPathExportMswCompletionsImpl::moveIntersectionsToSuperValves(MainBoreSegments mainBoreSegments) void RicWellPathExportMswCompletionsImpl::moveIntersectionsToICVs(
const std::vector<std::shared_ptr<RicMswSegment>>& mainBoreSegments,
const std::vector<const RimPerforationInterval*>& perforationIntervals,
RiaEclipseUnitTools::UnitSystem unitSystem)
{
std::map<const RimWellPathValve*, std::shared_ptr<RicMswPerforationICV>> icvCompletionMap;
for (std::shared_ptr<RicMswSegment> segment : mainBoreSegments)
{
for (auto completion : segment->completions())
{
std::shared_ptr<RicMswPerforationICV> icv = std::dynamic_pointer_cast<RicMswPerforationICV>(completion);
if (icv)
{
icvCompletionMap[icv->wellPathValve()] = icv;
}
}
}
for (std::shared_ptr<RicMswSegment> segment : mainBoreSegments)
{
std::vector<std::shared_ptr<RicMswCompletion>> perforations;
for (auto completionPtr : segment->completions())
{
if (completionPtr->completionType() == RigCompletionData::PERFORATION)
{
perforations.push_back(completionPtr);
}
}
for (const RimPerforationInterval* interval : perforationIntervals)
{
if (!interval->isChecked()) continue;
std::vector<const RimWellPathValve*> perforationValves;
interval->descendantsIncludingThisOfType(perforationValves);
for (const RimWellPathValve* valve : perforationValves)
{
if (!valve->isChecked()) continue;
if (valve->componentType() != RiaDefines::ICV) continue;
auto icvIt = icvCompletionMap.find(valve);
if (icvIt == icvCompletionMap.end()) continue;
std::shared_ptr<RicMswPerforationICV> icvCompletion = icvIt->second;
CVF_ASSERT(icvCompletion);
std::pair<double, double> valveSegment = valve->valveSegments().front();
double overlapStart = std::max(valveSegment.first, segment->startMD());
double overlapEnd = std::min(valveSegment.second, segment->endMD());
double overlap = std::max(0.0, overlapEnd - overlapStart);
if (overlap > 0.0)
{
CVF_ASSERT(icvCompletion->subSegments().size() == 1u);
for (auto perforationPtr : perforations)
{
for (auto subSegmentPtr : perforationPtr->subSegments())
{
for (auto intersectionPtr : subSegmentPtr->intersections())
{
icvCompletion->subSegments()[0]->addIntersection(intersectionPtr);
}
}
segment->removeCompletion(perforationPtr);
}
}
}
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicWellPathExportMswCompletionsImpl::moveIntersectionsToSuperICDsOrAICDs(MainBoreSegments mainBoreSegments)
{ {
for (auto segmentPtr : mainBoreSegments) for (auto segmentPtr : mainBoreSegments)
{ {
@ -1288,8 +1406,7 @@ void RicWellPathExportMswCompletionsImpl::moveIntersectionsToSuperValves(MainBor
std::vector<std::shared_ptr<RicMswCompletion>> perforations; std::vector<std::shared_ptr<RicMswCompletion>> perforations;
for (auto completionPtr : segmentPtr->completions()) for (auto completionPtr : segmentPtr->completions())
{ {
if (completionPtr->completionType() == RigCompletionData::PERFORATION_ICD || if (RigCompletionData::isPerforationValve(completionPtr->completionType()))
completionPtr->completionType() == RigCompletionData::PERFORATION_AICD)
{ {
superValve = completionPtr; superValve = completionPtr;
} }
@ -1384,8 +1501,8 @@ void RicWellPathExportMswCompletionsImpl::assignFishbonesLateralIntersections(co
size_t i = 0u, j = 0u, k = 0u; size_t i = 0u, j = 0u, k = 0u;
localGrid->ijkFromCellIndex(localGridIdx, &i, &j, &k); localGrid->ijkFromCellIndex(localGridIdx, &i, &j, &k);
std::shared_ptr<RicMswSubSegment> subSegment(new RicMswSubSegment( std::shared_ptr<RicMswSubSegment> subSegment(
previousExitMD, cellIntInfo.endMD, previousExitTVD, cellIntInfo.endTVD)); new RicMswSubSegment(previousExitMD, cellIntInfo.endMD, previousExitTVD, cellIntInfo.endTVD));
std::shared_ptr<RicMswSubSegmentCellIntersection> intersection(new RicMswSubSegmentCellIntersection( std::shared_ptr<RicMswSubSegmentCellIntersection> intersection(new RicMswSubSegmentCellIntersection(
gridName, cellIntInfo.globCellIndex, cvf::Vec3st(i, j, k), cellIntInfo.intersectionLengthsInCellCS)); gridName, cellIntInfo.globCellIndex, cvf::Vec3st(i, j, k), cellIntInfo.intersectionLengthsInCellCS));
@ -1485,10 +1602,8 @@ void RicWellPathExportMswCompletionsImpl::assignPerforationIntersections(const s
{ {
size_t currCellId = cellIntInfo.globCellIndex; size_t currCellId = cellIntInfo.globCellIndex;
std::shared_ptr<RicMswSubSegment> subSegment(new RicMswSubSegment(overlapStart, std::shared_ptr<RicMswSubSegment> subSegment(
overlapEnd, new RicMswSubSegment(overlapStart, overlapEnd, cellIntInfo.startTVD, cellIntInfo.endTVD));
cellIntInfo.startTVD,
cellIntInfo.endTVD));
for (const RigCompletionData& compIntersection : completionData) for (const RigCompletionData& compIntersection : completionData)
{ {
const RigCompletionDataGridCell& cell = compIntersection.completionDataGridCell(); const RigCompletionDataGridCell& cell = compIntersection.completionDataGridCell();

15
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportMswCompletionsImpl.h
View File

@ -107,14 +107,19 @@ private:
RimEclipseCase* eclipseCase, RimEclipseCase* eclipseCase,
bool* foundSubGridIntersections); bool* foundSubGridIntersections);
static void assignSuperValveCompletions(std::vector<std::shared_ptr<RicMswSegment>>& mainBoreSegments, static void createValveCompletions(std::vector<std::shared_ptr<RicMswSegment>>& mainBoreSegments,
const std::vector<const RimPerforationInterval*>& perforationIntervals);
static void assignValveContributionsToSuperValves(const std::vector<std::shared_ptr<RicMswSegment>>& mainBoreSegments,
const std::vector<const RimPerforationInterval*>& perforationIntervals, const std::vector<const RimPerforationInterval*>& perforationIntervals,
RiaEclipseUnitTools::UnitSystem unitSystem); RiaEclipseUnitTools::UnitSystem unitSystem);
static void moveIntersectionsToSuperValves(MainBoreSegments mainBoreSegments); static void assignValveContributionsToSuperICDsOrAICDs(const std::vector<std::shared_ptr<RicMswSegment>>& mainBoreSegments,
const std::vector<const RimPerforationInterval*>& perforationIntervals,
RiaEclipseUnitTools::UnitSystem unitSystem);
static void moveIntersectionsToICVs(const std::vector<std::shared_ptr<RicMswSegment>>& mainBoreSegments,
const std::vector<const RimPerforationInterval*>& perforationIntervals,
RiaEclipseUnitTools::UnitSystem unitSystem);
static void moveIntersectionsToSuperICDsOrAICDs(MainBoreSegments mainBoreSegments);
static void assignFishbonesLateralIntersections(const RimEclipseCase* caseToApply, static void assignFishbonesLateralIntersections(const RimEclipseCase* caseToApply,
const RimFishbonesMultipleSubs* fishbonesSubs, const RimFishbonesMultipleSubs* fishbonesSubs,

24
ApplicationCode/ReservoirDataModel/Completions/RigCompletionData.cpp
View File

@ -102,6 +102,30 @@ RigCompletionData& RigCompletionData::operator=(const RigCompletionData& other)
return *this; return *this;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigCompletionData::isPerforationValve(CompletionType type)
{
return type == PERFORATION_AICD || type == PERFORATION_ICD || type == PERFORATION_ICV;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigCompletionData::isValve(CompletionType type)
{
return isPerforationValve(type) || type == FISHBONES_ICD;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigCompletionData::isWsegValveTypes(CompletionType type)
{
return type == FISHBONES_ICD || type == PERFORATION_ICD || type == PERFORATION_ICV;
}
//================================================================================================== //==================================================================================================
/// ///
//================================================================================================== //==================================================================================================

6
ApplicationCode/ReservoirDataModel/Completions/RigCompletionData.h
View File

@ -69,6 +69,7 @@ public:
FISHBONES_ICD, FISHBONES_ICD,
PERFORATION_ICD, PERFORATION_ICD,
PERFORATION_AICD, PERFORATION_AICD,
PERFORATION_ICV,
CT_UNDEFINED CT_UNDEFINED
}; };
@ -80,6 +81,11 @@ public:
bool operator<(const RigCompletionData& other) const; bool operator<(const RigCompletionData& other) const;
RigCompletionData& operator=(const RigCompletionData& other); RigCompletionData& operator=(const RigCompletionData& other);
static bool isPerforationValve(CompletionType type);
static bool isValve(CompletionType type);
static bool isWsegValveTypes(CompletionType type);
void setFromFracture(double transmissibility, double skinFactor, double diameter); void setFromFracture(double transmissibility, double skinFactor, double diameter);
void setSecondOrderingValue(double orderingValue); void setSecondOrderingValue(double orderingValue);
void setDiameter(double diameter); void setDiameter(double diameter);