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

#1653 Make fracture mesh visualization independent of active view.

Browse Source 
Removed use of timestep index in rimfracture (use template timestep)

Remove display value from fracture cell
This commit is contained in:
Jacob Støren 2017-06-26 10:28:23 +02:00
parent febdabc6c6
commit 9d1cc2eb19
7 changed files with 81 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
ApplicationCode/ModelVisualization/RivWellFracturePartMgr.cpp
View File

@ -154,13 +154,13 @@ void RivWellFracturePartMgr::applyResultTextureColor(const RimEclipseView* activ
cvf::ref<cvf::Vec2fArray> textureCoords = new cvf::Vec2fArray; cvf::ref<cvf::Vec2fArray> textureCoords = new cvf::Vec2fArray;
textureCoords->resize(geo->vertexCount()); textureCoords->resize(geo->vertexCount());
int timeStepIndex = m_rimFracture->stimPlanTimeIndexToPlot; int timeStepIndex = stimPlanFracTemplate->activeTimeStepIndex();
std::vector<std::vector<double> > dataToPlot = stimPlanFracTemplate->resultValues(activeView->stimPlanColors->resultName(), std::vector<std::vector<double> > dataToPlot = stimPlanFracTemplate->resultValues(activeView->stimPlanColors->resultName(),
activeView->stimPlanColors->unit(), activeView->stimPlanColors->unit(),
timeStepIndex); timeStepIndex);
int i = 0; int i = 0;
for (std::vector<double> depthData : dataToPlot) for (const std::vector<double>& depthData : dataToPlot)
{ {
std::vector<double> mirroredValuesAtDepth = mirrorDataAtSingleDepth(depthData); std::vector<double> mirroredValuesAtDepth = mirrorDataAtSingleDepth(depthData);
for (double gridXdata : mirroredValuesAtDepth) for (double gridXdata : mirroredValuesAtDepth)
@ -230,7 +230,8 @@ void RivWellFracturePartMgr::generateFractureOutlinePolygonPart(const caf::Displ
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RivWellFracturePartMgr::generateStimPlanMeshPart(const caf::DisplayCoordTransform* displayCoordTransform) void RivWellFracturePartMgr::generateStimPlanMeshPart(const caf::DisplayCoordTransform* displayCoordTransform,
const RimEclipseView* activeView)
{ {
m_stimPlanMeshPart = nullptr; m_stimPlanMeshPart = nullptr;
@ -239,7 +240,9 @@ void RivWellFracturePartMgr::generateStimPlanMeshPart(const caf::DisplayCoordTra
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate()); RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate());
if (!stimPlanFracTemplate) return; if (!stimPlanFracTemplate) return;
cvf::ref<cvf::DrawableGeo> stimPlanMeshGeo = createStimPlanMeshDrawable(stimPlanFracTemplate, displayCoordTransform); cvf::ref<cvf::DrawableGeo> stimPlanMeshGeo = createStimPlanMeshDrawable(stimPlanFracTemplate,
displayCoordTransform,
activeView);
if (stimPlanMeshGeo.notNull()) if (stimPlanMeshGeo.notNull())
{ {
m_stimPlanMeshPart = new cvf::Part(0, "StimPlanMesh"); m_stimPlanMeshPart = new cvf::Part(0, "StimPlanMesh");
@ -260,7 +263,8 @@ void RivWellFracturePartMgr::generateStimPlanMeshPart(const caf::DisplayCoordTra
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
cvf::ref<cvf::DrawableGeo> RivWellFracturePartMgr::createStimPlanMeshDrawable(RimStimPlanFractureTemplate* stimPlanFracTemplate, cvf::ref<cvf::DrawableGeo> RivWellFracturePartMgr::createStimPlanMeshDrawable(RimStimPlanFractureTemplate* stimPlanFracTemplate,
const caf::DisplayCoordTransform* displayCoordTransform) const caf::DisplayCoordTransform* displayCoordTransform,
const RimEclipseView* activeView)
{ {
//TODO: This is needed to avoid errors when loading project with stimPlan fractures with multipled timesteps. //TODO: This is needed to avoid errors when loading project with stimPlan fractures with multipled timesteps.
//Should probably be moved, since it now is called twice in some cases... //Should probably be moved, since it now is called twice in some cases...
@ -269,10 +273,18 @@ cvf::ref<cvf::DrawableGeo> RivWellFracturePartMgr::createStimPlanMeshDrawable(Ri
std::vector<RigFractureCell> stimPlanCells = stimPlanFracTemplate->fractureGrid()->fractureCells(); std::vector<RigFractureCell> stimPlanCells = stimPlanFracTemplate->fractureGrid()->fractureCells();
std::vector<cvf::Vec3f> stimPlanMeshVertices; std::vector<cvf::Vec3f> stimPlanMeshVertices;
for (RigFractureCell stimPlanCell : stimPlanCells) QString resultNameFromColors = activeView->stimPlanColors->resultName();
QString resultUnitFromColors = activeView->stimPlanColors->unit();
std::vector<double> prCellResults = stimPlanFracTemplate->fractureGridResults(resultNameFromColors,
resultUnitFromColors,
stimPlanFracTemplate->activeTimeStepIndex());
for ( size_t cIdx = 0; cIdx < stimPlanCells.size() ; ++cIdx)
{ {
if (stimPlanCell.getDisplayValue() > 1e-7) if (prCellResults[cIdx] > 1e-7)
{ {
const RigFractureCell& stimPlanCell = stimPlanCells[cIdx];
std::vector<cvf::Vec3d> stimPlanCellPolygon = stimPlanCell.getPolygon(); std::vector<cvf::Vec3d> stimPlanCellPolygon = stimPlanCell.getPolygon();
for (cvf::Vec3d cellCorner : stimPlanCellPolygon) for (cvf::Vec3d cellCorner : stimPlanCellPolygon)
{ {
@ -435,7 +447,7 @@ void RivWellFracturePartMgr::appendGeometryPartsToModel(cvf::ModelBasicList* mod
if (stimPlanFracTemplate->showStimPlanMesh()) if (stimPlanFracTemplate->showStimPlanMesh())
{ {
generateStimPlanMeshPart(displayCoordTransform.p()); generateStimPlanMeshPart(displayCoordTransform.p(), eclView);
} }
} }
else // Ellipse else // Ellipse

6
ApplicationCode/ModelVisualization/RivWellFracturePartMgr.h
View File

@ -66,11 +66,13 @@ private:
void applyResultTextureColor(const RimEclipseView* activeView); void applyResultTextureColor(const RimEclipseView* activeView);
void generateFractureOutlinePolygonPart(const caf::DisplayCoordTransform* displayCoordTransform); void generateFractureOutlinePolygonPart(const caf::DisplayCoordTransform* displayCoordTransform);
void generateStimPlanMeshPart(const caf::DisplayCoordTransform* displayCoordTransform); void generateStimPlanMeshPart(const caf::DisplayCoordTransform* displayCoordTransform,
const RimEclipseView* activeView);
cvf::ref<cvf::DrawableGeo> createPolygonDrawable(const caf::DisplayCoordTransform* displayCoordTransform); cvf::ref<cvf::DrawableGeo> createPolygonDrawable(const caf::DisplayCoordTransform* displayCoordTransform);
cvf::ref<cvf::DrawableGeo> createStimPlanMeshDrawable(RimStimPlanFractureTemplate* stimPlanFracTemplate, cvf::ref<cvf::DrawableGeo> createStimPlanMeshDrawable(RimStimPlanFractureTemplate* stimPlanFracTemplate,
const caf::DisplayCoordTransform* displayCoordTransform); const caf::DisplayCoordTransform* displayCoordTransform,
const RimEclipseView* activeView);
void getPolygonBB(float &polygonXmin, void getPolygonBB(float &polygonXmin,
float &polygonXmax, float &polygonXmax,

18
ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.cpp
View File

@ -356,6 +356,14 @@ std::vector<std::vector<double>> RimStimPlanFractureTemplate::resultValues(const
return m_stimPlanFractureDefinitionData->getDataAtTimeIndex(resultName, unitName, timeStepIndex); return m_stimPlanFractureDefinitionData->getDataAtTimeIndex(resultName, unitName, timeStepIndex);
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RimStimPlanFractureTemplate::fractureGridResults(const QString& resultName, const QString& unitName, size_t timeStepIndex) const
{
return m_stimPlanFractureDefinitionData->fractureGridResults(resultName, unitName, timeStepIndex);
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -369,17 +377,9 @@ const RigFractureGrid* RimStimPlanFractureTemplate::fractureGrid() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimStimPlanFractureTemplate::updateFractureGrid() void RimStimPlanFractureTemplate::updateFractureGrid()
{ {
RimEclipseView* activeView = dynamic_cast<RimEclipseView*>(RiaApplication::instance()->activeReservoirView()); m_fractureGrid = m_stimPlanFractureDefinitionData->createFractureGrid(m_activeTimeStepIndex,
if (!activeView) return;
QString resultNameFromColors = activeView->stimPlanColors->resultName();
QString resultUnitFromColors = activeView->stimPlanColors->unit();
m_fractureGrid = m_stimPlanFractureDefinitionData->createFractureGrid(resultNameFromColors,
resultUnitFromColors,
m_activeTimeStepIndex,
fractureTemplateUnit, fractureTemplateUnit,
m_wellPathDepthAtFracture); m_wellPathDepthAtFracture);
} }

6
ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.h
View File

@ -77,9 +77,7 @@ public:
std::vector<std::pair<QString, QString> > resultNamesWithUnit() const; std::vector<std::pair<QString, QString> > resultNamesWithUnit() const;
void computeMinMax(const QString& resultName, const QString& unitName, double* minValue, double* maxValue) const; void computeMinMax(const QString& resultName, const QString& unitName, double* minValue, double* maxValue) const;
std::vector<std::vector<double>> resultValues(const QString& resultName, const QString& unitName, size_t timeStepIndex) const; std::vector<std::vector<double>> resultValues(const QString& resultName, const QString& unitName, size_t timeStepIndex) const;
std::vector<double> fractureGridResults(const QString& resultName, const QString& unitName, size_t timeStepIndex) const;
// OBSOLETE : Function used by upscaling only
void getStimPlanDataAsPolygonsAndValues(std::vector<std::vector<cvf::Vec3d> > &cellsAsPolygons, std::vector<double> &parameterValue, const QString& resultName, const QString& unitName, size_t timeStepIndex);
protected: protected:
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override; virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
@ -94,8 +92,6 @@ private:
void setDepthOfWellPathAtFracture(); void setDepthOfWellPathAtFracture();
QString getUnitForStimPlanParameter(QString parameterName); QString getUnitForStimPlanParameter(QString parameterName);
void sortPolygon(std::vector<cvf::Vec3f> &polygon);
caf::PdmField<int> m_activeTimeStepIndex; caf::PdmField<int> m_activeTimeStepIndex;
caf::PdmField<bool> m_showStimPlanMesh; caf::PdmField<bool> m_showStimPlanMesh;

5
ApplicationCode/ReservoirDataModel/RigFractureCell.h
View File

@ -39,21 +39,16 @@ public:
const std::vector<cvf::Vec3d>& getPolygon() const { return m_polygon; } const std::vector<cvf::Vec3d>& getPolygon() const { return m_polygon; }
double getConductivtyValue() const { return m_concutivityValue; } double getConductivtyValue() const { return m_concutivityValue; }
double getDisplayValue() { return m_displayValue; }
size_t getI() const { return m_i; } size_t getI() const { return m_i; }
size_t getJ() const { return m_j; } size_t getJ() const { return m_j; }
bool hasNonZeroConductivity() const { return m_concutivityValue > 1e-7; } bool hasNonZeroConductivity() const { return m_concutivityValue > 1e-7; }
void setConductivityValue(double cond) { m_concutivityValue = cond; } void setConductivityValue(double cond) { m_concutivityValue = cond; }
void setDisplayValue(double value) { m_displayValue = value; };
double cellSizeX() const; double cellSizeX() const;
double cellSizeZ() const; double cellSizeZ() const;
private: private:
std::vector<cvf::Vec3d> m_polygon; std::vector<cvf::Vec3d> m_polygon;
double m_displayValue;
double m_concutivityValue; double m_concutivityValue;
size_t m_i; size_t m_i;
size_t m_j; size_t m_j;

54
ApplicationCode/ReservoirDataModel/RigStimPlanFractureDefinition.cpp
View File

@ -143,9 +143,7 @@ std::vector<std::vector<double>> RigStimPlanFractureDefinition::getMirroredDataA
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(const QString& resultNameFromColors, cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(int m_activeTimeStepIndex,
const QString& resultUnitFromColors,
int m_activeTimeStepIndex,
RiaEclipseUnitTools::UnitSystemType fractureTemplateUnit, RiaEclipseUnitTools::UnitSystemType fractureTemplateUnit,
double m_wellPathDepthAtFracture) double m_wellPathDepthAtFracture)
{ {
@ -154,10 +152,6 @@ cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(cons
bool wellCenterStimPlanCellFound = false; bool wellCenterStimPlanCellFound = false;
std::vector<std::vector<double>> displayPropertyValuesAtTimeStep = this->getMirroredDataAtTimeIndex(resultNameFromColors,
resultUnitFromColors,
m_activeTimeStepIndex);
QString condUnit; QString condUnit;
if ( fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC ) condUnit = "md-m"; if ( fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC ) condUnit = "md-m";
if ( fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD ) condUnit = "md-ft"; if ( fractureTemplateUnit == RiaEclipseUnitTools::UNITS_FIELD ) condUnit = "md-ft";
@ -178,10 +172,10 @@ cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(cons
for ( int j = 0; j < depthCoords.size() - 1; j++ ) for ( int j = 0; j < depthCoords.size() - 1; j++ )
{ {
std::vector<cvf::Vec3d> cellPolygon; std::vector<cvf::Vec3d> cellPolygon;
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[i]), static_cast<float>(depthCoords[j]), 0.0)); cellPolygon.push_back(cvf::Vec3d(xCoords[i], depthCoords[j], 0.0));
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[i + 1]), static_cast<float>(depthCoords[j]), 0.0)); cellPolygon.push_back(cvf::Vec3d(xCoords[i + 1], depthCoords[j], 0.0));
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[i + 1]), static_cast<float>(depthCoords[j + 1]), 0.0)); cellPolygon.push_back(cvf::Vec3d(xCoords[i + 1], depthCoords[j + 1], 0.0));
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[i]), static_cast<float>(depthCoords[j + 1]), 0.0)); cellPolygon.push_back(cvf::Vec3d(xCoords[i], depthCoords[j + 1], 0.0));
RigFractureCell stimPlanCell(cellPolygon, i, j); RigFractureCell stimPlanCell(cellPolygon, i, j);
if ( conductivityValuesAtTimeStep.size() > 0 ) //Assuming vector to be of correct length, or no values if ( conductivityValuesAtTimeStep.size() > 0 ) //Assuming vector to be of correct length, or no values
@ -193,14 +187,6 @@ cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(cons
stimPlanCell.setConductivityValue(cvf::UNDEFINED_DOUBLE); stimPlanCell.setConductivityValue(cvf::UNDEFINED_DOUBLE);
} }
if ( displayPropertyValuesAtTimeStep.size() > 0 )
{
stimPlanCell.setDisplayValue(displayPropertyValuesAtTimeStep[j + 1][i + 1]);
}
else
{
stimPlanCell.setDisplayValue(cvf::UNDEFINED_DOUBLE);
}
if ( cellPolygon[0].x() < 0.0 && cellPolygon[1].x() > 0.0 ) if ( cellPolygon[0].x() < 0.0 && cellPolygon[1].x() > 0.0 )
{ {
@ -232,6 +218,36 @@ cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(cons
return m_fractureGrid; return m_fractureGrid;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RigStimPlanFractureDefinition::fractureGridResults(const QString& resultName,
const QString& unitName,
size_t timeStepIndex) const
{
std::vector<double> fractureGridResults;
std::vector<std::vector<double>> resultValuesAtTimeStep = this->getMirroredDataAtTimeIndex(resultName,
unitName,
timeStepIndex);
for ( int i = 0; i < mirroredGridXCount() - 2; i++ )
{
for ( int j = 0; j < depthCount() - 2; j++ )
{
if ( j+1 < resultValuesAtTimeStep.size() && i+1 < resultValuesAtTimeStep[j + 1].size() )
{
fractureGridResults.push_back(resultValuesAtTimeStep[j + 1][i + 1]);
}
else
{
fractureGridResults.push_back(HUGE_VAL);
}
}
}
return fractureGridResults;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

21
ApplicationCode/ReservoirDataModel/RigStimPlanFractureDefinition.h
View File

@ -47,10 +47,10 @@ public:
RigStimPlanFractureDefinition(); RigStimPlanFractureDefinition();
~RigStimPlanFractureDefinition(); ~RigStimPlanFractureDefinition();
RiaEclipseUnitTools::UnitSystem unitSet() { return m_unitSet; } RiaEclipseUnitTools::UnitSystem unitSet() const { return m_unitSet; }
void setUnitSet(RiaEclipseUnitTools::UnitSystem unitset) { m_unitSet = unitset;} void setUnitSet(RiaEclipseUnitTools::UnitSystem unitset) { m_unitSet = unitset;}
size_t gridXCount() { return m_gridXs.size();} size_t gridXCount() const { return m_gridXs.size();}
void setGridXs(const std::vector<double>& gridXs) { m_gridXs = gridXs; } void setGridXs(const std::vector<double>& gridXs) { m_gridXs = gridXs; }
@ -59,9 +59,9 @@ public:
void setGridYs(const std::vector<double>& gridYs) { m_gridYs = gridYs; } void setGridYs(const std::vector<double>& gridYs) { m_gridYs = gridYs; }
double minDepth() { return depths[0]; } double minDepth() const { return depths[0]; }
double maxDepth() { return depths.back(); } double maxDepth() const { return depths.back(); }
size_t depthCount() { return depths.size(); } size_t depthCount() const { return depths.size(); }
// Grid Geometry // Grid Geometry
@ -72,12 +72,11 @@ public:
size_t timeStepIndex) const; size_t timeStepIndex) const;
cvf::ref<RigFractureGrid> createFractureGrid(const QString& resultNameFromColors, cvf::ref<RigFractureGrid> createFractureGrid(int m_activeTimeStepIndex,
const QString& resultUnitFromColors,
int m_activeTimeStepIndex,
RiaEclipseUnitTools::UnitSystemType fractureTemplateUnit, RiaEclipseUnitTools::UnitSystemType fractureTemplateUnit,
double m_wellPathDepthAtFracture); double m_wellPathDepthAtFracture);
void createFractureTriangleGeometry(double m_wellPathDepthAtFracture, void createFractureTriangleGeometry(double m_wellPathDepthAtFracture,
RiaEclipseUnitTools::UnitSystem neededUnit, RiaEclipseUnitTools::UnitSystem neededUnit,
const QString& fractureUserName, const QString& fractureUserName,
@ -100,6 +99,9 @@ public:
size_t totalNumberTimeSteps(); size_t totalNumberTimeSteps();
void setDataAtTimeValue(QString resultName, QString unit, std::vector<std::vector<double>> data, double timeStepValue); void setDataAtTimeValue(QString resultName, QString unit, std::vector<std::vector<double>> data, double timeStepValue);
const std::vector<std::vector<double>>& getDataAtTimeIndex(const QString& resultName, const QString& unit, size_t timeStepIndex) const; const std::vector<std::vector<double>>& getDataAtTimeIndex(const QString& resultName, const QString& unit, size_t timeStepIndex) const;
std::vector<double> fractureGridResults(const QString& resultName,
const QString& unitName,
size_t timeStepIndex) const;
void computeMinMax(const QString& resultName, const QString& unit, double* minValue, double* maxValue) const; void computeMinMax(const QString& resultName, const QString& unit, double* minValue, double* maxValue) const;
// Setup // Setup
@ -108,7 +110,8 @@ private:
bool timeStepExisist(double timeStepValue); bool timeStepExisist(double timeStepValue);
size_t getTimeStepIndex(double timeStepValue); size_t getTimeStepIndex(double timeStepValue);
size_t resultIndex(const QString& resultName, const QString& unit) const; size_t resultIndex(const QString& resultName, const QString& unit) const;
size_t mirroredGridXCount() const { return m_gridXs.size() ? m_gridXs.size() + m_gridXs.size() - 1 : 0 ;}
RiaEclipseUnitTools::UnitSystem m_unitSet; RiaEclipseUnitTools::UnitSystem m_unitSet;
std::vector<double> m_gridXs; std::vector<double> m_gridXs;
std::vector<double> m_gridYs; std::vector<double> m_gridYs;