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;
textureCoords->resize(geo->vertexCount());
int timeStepIndex = m_rimFracture->stimPlanTimeIndexToPlot;
int timeStepIndex = stimPlanFracTemplate->activeTimeStepIndex();
std::vector<std::vector<double> > dataToPlot = stimPlanFracTemplate->resultValues(activeView->stimPlanColors->resultName(),
activeView->stimPlanColors->unit(),
timeStepIndex);
int i = 0;
for (std::vector<double> depthData : dataToPlot)
for (const std::vector<double>& depthData : dataToPlot)
{
std::vector<double> mirroredValuesAtDepth = mirrorDataAtSingleDepth(depthData);
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;
@ -239,7 +240,9 @@ void RivWellFracturePartMgr::generateStimPlanMeshPart(const caf::DisplayCoordTra
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate());
if (!stimPlanFracTemplate) return;
cvf::ref<cvf::DrawableGeo> stimPlanMeshGeo = createStimPlanMeshDrawable(stimPlanFracTemplate, displayCoordTransform);
cvf::ref<cvf::DrawableGeo> stimPlanMeshGeo = createStimPlanMeshDrawable(stimPlanFracTemplate,
displayCoordTransform,
activeView);
if (stimPlanMeshGeo.notNull())
{
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,
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.
//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<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();
for (cvf::Vec3d cellCorner : stimPlanCellPolygon)
{
@ -435,7 +447,7 @@ void RivWellFracturePartMgr::appendGeometryPartsToModel(cvf::ModelBasicList* mod
if (stimPlanFracTemplate->showStimPlanMesh())
{
generateStimPlanMeshPart(displayCoordTransform.p());
generateStimPlanMeshPart(displayCoordTransform.p(), eclView);
}
}
else // Ellipse

6
ApplicationCode/ModelVisualization/RivWellFracturePartMgr.h
View File

@ -66,11 +66,13 @@ private:
void applyResultTextureColor(const RimEclipseView* activeView);
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> createStimPlanMeshDrawable(RimStimPlanFractureTemplate* stimPlanFracTemplate,
const caf::DisplayCoordTransform* displayCoordTransform);
const caf::DisplayCoordTransform* displayCoordTransform,
const RimEclipseView* activeView);
void getPolygonBB(float &polygonXmin,
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);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
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()
{
RimEclipseView* activeView = dynamic_cast<RimEclipseView*>(RiaApplication::instance()->activeReservoirView());
if (!activeView) return;
QString resultNameFromColors = activeView->stimPlanColors->resultName();
QString resultUnitFromColors = activeView->stimPlanColors->unit();
m_fractureGrid = m_stimPlanFractureDefinitionData->createFractureGrid(resultNameFromColors,
resultUnitFromColors,
m_activeTimeStepIndex,
m_fractureGrid = m_stimPlanFractureDefinitionData->createFractureGrid(m_activeTimeStepIndex,
fractureTemplateUnit,
m_wellPathDepthAtFracture);
}

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

@ -77,9 +77,7 @@ public:
std::vector<std::pair<QString, QString> > resultNamesWithUnit() 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;
// 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);
std::vector<double> fractureGridResults(const QString& resultName, const QString& unitName, size_t timeStepIndex) const;
protected:
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
@ -94,8 +92,6 @@ private:
void setDepthOfWellPathAtFracture();
QString getUnitForStimPlanParameter(QString parameterName);
void sortPolygon(std::vector<cvf::Vec3f> &polygon);
caf::PdmField<int> m_activeTimeStepIndex;
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; }
double getConductivtyValue() const { return m_concutivityValue; }
double getDisplayValue() { return m_displayValue; }
size_t getI() const { return m_i; }
size_t getJ() const { return m_j; }
bool hasNonZeroConductivity() const { return m_concutivityValue > 1e-7; }
void setConductivityValue(double cond) { m_concutivityValue = cond; }
void setDisplayValue(double value) { m_displayValue = value; };
double cellSizeX() const;
double cellSizeZ() const;
private:
std::vector<cvf::Vec3d> m_polygon;
double m_displayValue;
double m_concutivityValue;
size_t m_i;
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,
const QString& resultUnitFromColors,
int m_activeTimeStepIndex,
cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(int m_activeTimeStepIndex,
RiaEclipseUnitTools::UnitSystemType fractureTemplateUnit,
double m_wellPathDepthAtFracture)
{
@ -154,10 +152,6 @@ cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(cons
bool wellCenterStimPlanCellFound = false;
std::vector<std::vector<double>> displayPropertyValuesAtTimeStep = this->getMirroredDataAtTimeIndex(resultNameFromColors,
resultUnitFromColors,
m_activeTimeStepIndex);
QString condUnit;
if ( fractureTemplateUnit == RiaEclipseUnitTools::UNITS_METRIC ) condUnit = "md-m";
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++ )
{
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(static_cast<float>(xCoords[i + 1]), static_cast<float>(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(static_cast<float>(xCoords[i]), static_cast<float>(depthCoords[j + 1]), 0.0));
cellPolygon.push_back(cvf::Vec3d(xCoords[i], depthCoords[j], 0.0));
cellPolygon.push_back(cvf::Vec3d(xCoords[i + 1], depthCoords[j], 0.0));
cellPolygon.push_back(cvf::Vec3d(xCoords[i + 1], depthCoords[j + 1], 0.0));
cellPolygon.push_back(cvf::Vec3d(xCoords[i], depthCoords[j + 1], 0.0));
RigFractureCell stimPlanCell(cellPolygon, i, j);
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);
}
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 )
{
@ -232,6 +218,36 @@ cvf::ref<RigFractureGrid> RigStimPlanFractureDefinition::createFractureGrid(cons
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();
RiaEclipseUnitTools::UnitSystem unitSet() { return m_unitSet; }
RiaEclipseUnitTools::UnitSystem unitSet() const { return m_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; }
@ -59,9 +59,9 @@ public:
void setGridYs(const std::vector<double>& gridYs) { m_gridYs = gridYs; }
double minDepth() { return depths[0]; }
double maxDepth() { return depths.back(); }
size_t depthCount() { return depths.size(); }
double minDepth() const { return depths[0]; }
double maxDepth() const { return depths.back(); }
size_t depthCount() const { return depths.size(); }
// Grid Geometry
@ -72,12 +72,11 @@ public:
size_t timeStepIndex) const;
cvf::ref<RigFractureGrid> createFractureGrid(const QString& resultNameFromColors,
const QString& resultUnitFromColors,
int m_activeTimeStepIndex,
cvf::ref<RigFractureGrid> createFractureGrid(int m_activeTimeStepIndex,
RiaEclipseUnitTools::UnitSystemType fractureTemplateUnit,
double m_wellPathDepthAtFracture);
void createFractureTriangleGeometry(double m_wellPathDepthAtFracture,
RiaEclipseUnitTools::UnitSystem neededUnit,
const QString& fractureUserName,
@ -100,6 +99,9 @@ public:
size_t totalNumberTimeSteps();
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;
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;
// Setup
@ -108,7 +110,8 @@ private:
bool timeStepExisist(double timeStepValue);
size_t getTimeStepIndex(double timeStepValue);
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;
std::vector<double> m_gridXs;
std::vector<double> m_gridYs;