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

#1487 Renaming RigStimPlanFracTemplateCell to RigFractureCell

Browse Source
This commit is contained in:
astridkbjorke 2017-05-30 11:52:19 +02:00
parent 8cf5f6983f
commit a8b6543c3c
18 changed files with 78 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
ApplicationCode/FileInterface/RifFractureExportTools.cpp
View File

@ -24,7 +24,7 @@
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigFracture.h" #include "RigFracture.h"
#include "RigFractureTransCalc.h" #include "RigFractureTransCalc.h"
#include "RigStimPlanFracTemplateCell.h" #include "RigFractureCell.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigEclipseToStimPlanCellTransmissibilityCalculator.h" #include "RigEclipseToStimPlanCellTransmissibilityCalculator.h"
#include "RigFractureTransmissibilityEquations.h" #include "RigFractureTransmissibilityEquations.h"
@ -236,7 +236,7 @@ void RifFractureExportTools::exportWellPathFracturesToEclipseDataInputFile(const
auto stimPlanCells = fractureGrid.fractureCells(); auto stimPlanCells = fractureGrid.fractureCells();
for (const RigStimPlanFracTemplateCell stimPlanCell : stimPlanCells) for (const RigFractureCell stimPlanCell : stimPlanCells)
{ {
if (stimPlanCell.getConductivtyValue() < 1e-7) continue; if (stimPlanCell.getConductivtyValue() < 1e-7) continue;
@ -267,14 +267,14 @@ void RifFractureExportTools::exportWellPathFracturesToEclipseDataInputFile(const
for (size_t j = 0; j < fractureGrid.jCellCount(); j++) for (size_t j = 0; j < fractureGrid.jCellCount(); j++)
{ {
size_t stimPlanCellIndex = fractureGrid.getGlobalIndexFromIJ(i, j); size_t stimPlanCellIndex = fractureGrid.getGlobalIndexFromIJ(i, j);
const RigStimPlanFracTemplateCell stimPlanCell = fractureGrid.cellFromIndex(stimPlanCellIndex); const RigFractureCell stimPlanCell = fractureGrid.cellFromIndex(stimPlanCellIndex);
if (stimPlanCell.getConductivtyValue() < 1e-7) continue; if (stimPlanCell.getConductivtyValue() < 1e-7) continue;
if (i < fractureGrid.iCellCount()-1) if (i < fractureGrid.iCellCount()-1)
{ {
size_t stimPlanCellNeighbourXIndex = fractureGrid.getGlobalIndexFromIJ(i + 1, j); size_t stimPlanCellNeighbourXIndex = fractureGrid.getGlobalIndexFromIJ(i + 1, j);
const RigStimPlanFracTemplateCell stimPlanCellNeighbourX = fractureGrid.cellFromIndex(stimPlanCellNeighbourXIndex); const RigFractureCell stimPlanCellNeighbourX = fractureGrid.cellFromIndex(stimPlanCellNeighbourXIndex);
double horizontalTransToXneigbour = double horizontalTransToXneigbour =
RigFractureTransmissibilityEquations::computeStimPlanCellTransmissibilityInFractureCenterToCenterForTwoCells(stimPlanCell.getConductivtyValue(), RigFractureTransmissibilityEquations::computeStimPlanCellTransmissibilityInFractureCenterToCenterForTwoCells(stimPlanCell.getConductivtyValue(),
@ -294,7 +294,7 @@ void RifFractureExportTools::exportWellPathFracturesToEclipseDataInputFile(const
if (j < fractureGrid.jCellCount()-1) if (j < fractureGrid.jCellCount()-1)
{ {
size_t stimPlanCellNeighbourZIndex = fractureGrid.getGlobalIndexFromIJ(i, j + 1); size_t stimPlanCellNeighbourZIndex = fractureGrid.getGlobalIndexFromIJ(i, j + 1);
const RigStimPlanFracTemplateCell stimPlanCellNeighbourZ = fractureGrid.cellFromIndex(stimPlanCellNeighbourZIndex); const RigFractureCell stimPlanCellNeighbourZ = fractureGrid.cellFromIndex(stimPlanCellNeighbourZIndex);
double verticalTransToZneigbour = double verticalTransToZneigbour =
RigFractureTransmissibilityEquations::computeStimPlanCellTransmissibilityInFractureCenterToCenterForTwoCells(stimPlanCell.getConductivtyValue(), RigFractureTransmissibilityEquations::computeStimPlanCellTransmissibilityInFractureCenterToCenterForTwoCells(stimPlanCell.getConductivtyValue(),
@ -324,7 +324,7 @@ void RifFractureExportTools::exportWellPathFracturesToEclipseDataInputFile(const
size_t stpWellCellIdx = stpCellIdxIsectDataPair.first; size_t stpWellCellIdx = stpCellIdxIsectDataPair.first;
RigWellPathStimplanIntersector::WellCellIntersection intersection = stpCellIdxIsectDataPair.second; RigWellPathStimplanIntersector::WellCellIntersection intersection = stpCellIdxIsectDataPair.second;
const RigStimPlanFracTemplateCell stimPlanWellCell = fractureGrid.cellFromIndex(stpWellCellIdx); const RigFractureCell stimPlanWellCell = fractureGrid.cellFromIndex(stpWellCellIdx);
double radialTrans = 0.0; double radialTrans = 0.0;
if (intersection.endpointCount) if (intersection.endpointCount)
@ -523,9 +523,9 @@ void RifFractureExportTools::printStimPlanCellsMatrixTransContributions(const st
double cDarcyInCorrectUnit = caseToApply->eclipseCaseData()->darchysValue(); double cDarcyInCorrectUnit = caseToApply->eclipseCaseData()->darchysValue();
std::vector<RigStimPlanFracTemplateCell> stimPlanCells = fracTemplateStimPlan->fractureGrid().fractureCells(); std::vector<RigFractureCell> stimPlanCells = fracTemplateStimPlan->fractureGrid().fractureCells();
for (RigStimPlanFracTemplateCell stimPlanCell : stimPlanCells) for (RigFractureCell stimPlanCell : stimPlanCells)
{ {
if (stimPlanCell.getConductivtyValue() < 1e-7) if (stimPlanCell.getConductivtyValue() < 1e-7)
{ {
@ -613,9 +613,9 @@ void RifFractureExportTools::printStimPlanFractureTrans(const std::vector<RimFra
} }
else return; else return;
std::vector<RigStimPlanFracTemplateCell> stimPlanCells = fracTemplateStimPlan->fractureGrid().fractureCells(); std::vector<RigFractureCell> stimPlanCells = fracTemplateStimPlan->fractureGrid().fractureCells();
for (RigStimPlanFracTemplateCell stimPlanCell : stimPlanCells) for (RigFractureCell stimPlanCell : stimPlanCells)
{ {
if (stimPlanCell.getConductivtyValue() < 1e-7) if (stimPlanCell.getConductivtyValue() < 1e-7)
{ {
@ -848,7 +848,7 @@ void RifFractureExportTools::printTransmissibilityFractureToWell(const std::vect
//RigStimPlanCell* stimPlanCell = fracTemplateStimPlan->getStimPlanCellAtIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second); //RigStimPlanCell* stimPlanCell = fracTemplateStimPlan->getStimPlanCellAtIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second);
const RigStimPlanFracTemplateCell& stimPlanCell = fracTemplateStimPlan->fractureGrid().cellFromIndex(fracTemplateStimPlan->fractureGrid().getGlobalIndexFromIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second)); const RigFractureCell& stimPlanCell = fracTemplateStimPlan->fractureGrid().cellFromIndex(fracTemplateStimPlan->fractureGrid().getGlobalIndexFromIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second));
double linTransInStimPlanCell = RigFractureTransmissibilityEquations::computeLinearTransmissibilityToWellinStimPlanCell(stimPlanCell.getConductivtyValue(), double linTransInStimPlanCell = RigFractureTransmissibilityEquations::computeLinearTransmissibilityToWellinStimPlanCell(stimPlanCell.getConductivtyValue(),
stimPlanCell.cellSizeX(), stimPlanCell.cellSizeX(),
@ -882,7 +882,7 @@ void RifFractureExportTools::printTransmissibilityFractureToWell(const std::vect
out << wellCenterStimPlanCellIJ.first; out << wellCenterStimPlanCellIJ.first;
out << wellCenterStimPlanCellIJ.second; out << wellCenterStimPlanCellIJ.second;
const RigStimPlanFracTemplateCell& stimPlanCell = fracTemplateStimPlan->fractureGrid().cellFromIndex(fracTemplateStimPlan->fractureGrid().getGlobalIndexFromIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second)); const RigFractureCell& stimPlanCell = fracTemplateStimPlan->fractureGrid().cellFromIndex(fracTemplateStimPlan->fractureGrid().getGlobalIndexFromIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second));
double radTransInStimPlanCell = RigFractureTransmissibilityEquations::computeRadialTransmissibilityToWellinStimPlanCell(stimPlanCell.getConductivtyValue(), double radTransInStimPlanCell = RigFractureTransmissibilityEquations::computeRadialTransmissibilityToWellinStimPlanCell(stimPlanCell.getConductivtyValue(),
stimPlanCell.cellSizeX(), stimPlanCell.cellSizeX(),

6
ApplicationCode/ModelVisualization/RivWellFracturePartMgr.cpp
View File

@ -27,7 +27,7 @@
#include "RimFracture.h" #include "RimFracture.h"
#include "RimFractureTemplate.h" #include "RimFractureTemplate.h"
#include "RimLegendConfig.h" #include "RimLegendConfig.h"
#include "RigStimPlanFracTemplateCell.h" #include "RigFractureCell.h"
#include "RimStimPlanColors.h" #include "RimStimPlanColors.h"
#include "RimStimPlanFractureTemplate.h" #include "RimStimPlanFractureTemplate.h"
@ -290,10 +290,10 @@ cvf::ref<cvf::DrawableGeo> RivWellFracturePartMgr::createStimPlanMeshDrawable(Ri
//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...
stimPlanFracTemplate->setupStimPlanCells(); stimPlanFracTemplate->setupStimPlanCells();
std::vector<RigStimPlanFracTemplateCell> stimPlanCells = stimPlanFracTemplate->fractureGrid().fractureCells(); std::vector<RigFractureCell> stimPlanCells = stimPlanFracTemplate->fractureGrid().fractureCells();
std::vector<cvf::Vec3f> stimPlanMeshVertices; std::vector<cvf::Vec3f> stimPlanMeshVertices;
for (RigStimPlanFracTemplateCell stimPlanCell : stimPlanCells) for (RigFractureCell stimPlanCell : stimPlanCells)
{ {
if (stimPlanCell.getDisplayValue() > 1e-7) if (stimPlanCell.getDisplayValue() > 1e-7)
{ {

6
ApplicationCode/ProjectDataModel/RimStimPlanFractureTemplate.cpp
View File

@ -26,7 +26,7 @@
#include "RimEclipseView.h" #include "RimEclipseView.h"
#include "RimFracture.h" #include "RimFracture.h"
#include "RimProject.h" #include "RimProject.h"
#include "RigStimPlanFracTemplateCell.h" #include "RigFractureCell.h"
#include "RimStimPlanColors.h" #include "RimStimPlanColors.h"
#include "RimStimPlanLegendConfig.h" #include "RimStimPlanLegendConfig.h"
@ -820,7 +820,7 @@ void RimStimPlanFractureTemplate::setupStimPlanCells()
QString resultNameFromColors = activeView->stimPlanColors->resultName(); QString resultNameFromColors = activeView->stimPlanColors->resultName();
QString resultUnitFromColors = activeView->stimPlanColors->unit(); QString resultUnitFromColors = activeView->stimPlanColors->unit();
std::vector<RigStimPlanFracTemplateCell> stimPlanCells; std::vector<RigFractureCell> stimPlanCells;
std::pair<size_t, size_t> wellCenterStimPlanCellIJ = std::make_pair(0,0); std::pair<size_t, size_t> wellCenterStimPlanCellIJ = std::make_pair(0,0);
bool wellCenterStimPlanCellFound = false; bool wellCenterStimPlanCellFound = false;
@ -850,7 +850,7 @@ void RimStimPlanFractureTemplate::setupStimPlanCells()
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 + 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(static_cast<float>(xCoords[i]), static_cast<float>(depthCoords[j + 1]), 0.0));
RigStimPlanFracTemplateCell 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
{ {
stimPlanCell.setConductivityValue(conductivityValuesAtTimeStep[j + 1][i + 1]); stimPlanCell.setConductivityValue(conductivityValuesAtTimeStep[j + 1][i + 1]);

4
ApplicationCode/ProjectDataModel/RimStimPlanFractureTemplate.h
View File

@ -32,12 +32,12 @@
#include "cvfVector3.h" #include "cvfVector3.h"
#include <vector> #include <vector>
#include "RigStimPlanFracTemplateCell.h" #include "RigFractureCell.h"
#include "RigFractureGrid.h" #include "RigFractureGrid.h"
class RigStimPlanFractureDefinition; class RigStimPlanFractureDefinition;
class RimStimPlanLegendConfig; class RimStimPlanLegendConfig;
class RigStimPlanFracTemplateCell; class RigFractureCell;
class RigFractureGrid; class RigFractureGrid;
//================================================================================================== //==================================================================================================

4
ApplicationCode/ReservoirDataModel/CMakeLists_files.cmake
View File

@ -61,9 +61,9 @@ ${CEE_CURRENT_LIST_DIR}RigWellPathStimplanIntersector.h
${CEE_CURRENT_LIST_DIR}RigTesselatorTools.h ${CEE_CURRENT_LIST_DIR}RigTesselatorTools.h
${CEE_CURRENT_LIST_DIR}RigCellGeometryTools.h ${CEE_CURRENT_LIST_DIR}RigCellGeometryTools.h
${CEE_CURRENT_LIST_DIR}RigStimPlanFractureDefinition.h ${CEE_CURRENT_LIST_DIR}RigStimPlanFractureDefinition.h
${CEE_CURRENT_LIST_DIR}RigStimPlanFracTemplateCell.h
${CEE_CURRENT_LIST_DIR}RigStimPlanUpscalingCalc.h ${CEE_CURRENT_LIST_DIR}RigStimPlanUpscalingCalc.h
${CEE_CURRENT_LIST_DIR}RigFractureGrid.h ${CEE_CURRENT_LIST_DIR}RigFractureGrid.h
${CEE_CURRENT_LIST_DIR}RigFractureCell.h
@ -123,9 +123,9 @@ ${CEE_CURRENT_LIST_DIR}RigWellPathStimplanIntersector.cpp
${CEE_CURRENT_LIST_DIR}RigTesselatorTools.cpp ${CEE_CURRENT_LIST_DIR}RigTesselatorTools.cpp
${CEE_CURRENT_LIST_DIR}RigCellGeometryTools.cpp ${CEE_CURRENT_LIST_DIR}RigCellGeometryTools.cpp
${CEE_CURRENT_LIST_DIR}RigStimPlanFractureDefinition.cpp ${CEE_CURRENT_LIST_DIR}RigStimPlanFractureDefinition.cpp
${CEE_CURRENT_LIST_DIR}RigStimPlanFracTemplateCell.cpp
${CEE_CURRENT_LIST_DIR}RigStimPlanUpscalingCalc.cpp ${CEE_CURRENT_LIST_DIR}RigStimPlanUpscalingCalc.cpp
${CEE_CURRENT_LIST_DIR}RigFractureGrid.cpp ${CEE_CURRENT_LIST_DIR}RigFractureGrid.cpp
${CEE_CURRENT_LIST_DIR}RigFractureCell.cpp
) )

4
ApplicationCode/ReservoirDataModel/RigEclipseToStimPlanCellTransmissibilityCalculator.cpp
View File

@ -20,7 +20,7 @@
#include "RigFractureTransmissibilityEquations.h" #include "RigFractureTransmissibilityEquations.h"
#include "RigStimPlanFracTemplateCell.h" #include "RigFractureCell.h"
#include "RigResultAccessorFactory.h" #include "RigResultAccessorFactory.h"
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigActiveCellInfo.h" #include "RigActiveCellInfo.h"
@ -40,7 +40,7 @@ RigEclipseToStimPlanCellTransmissibilityCalculator::RigEclipseToStimPlanCellTran
cvf::Mat4f fractureTransform, cvf::Mat4f fractureTransform,
double skinFactor, double skinFactor,
double cDarcy, double cDarcy,
const RigStimPlanFracTemplateCell& stimPlanCell) const RigFractureCell& stimPlanCell)
: m_case(caseToApply), : m_case(caseToApply),
m_fractureTransform(fractureTransform), m_fractureTransform(fractureTransform),
m_fractureSkinFactor(skinFactor), m_fractureSkinFactor(skinFactor),

6
ApplicationCode/ReservoirDataModel/RigEclipseToStimPlanCellTransmissibilityCalculator.h
View File

@ -24,7 +24,7 @@
#include "cvfMatrix4.h" #include "cvfMatrix4.h"
class RimEclipseCase; class RimEclipseCase;
class RigStimPlanFracTemplateCell; class RigFractureCell;
//================================================================================================== //==================================================================================================
/// ///
@ -37,7 +37,7 @@ public:
cvf::Mat4f fractureTransform, cvf::Mat4f fractureTransform,
double skinFactor, double skinFactor,
double cDarcy, double cDarcy,
const RigStimPlanFracTemplateCell& stimPlanCell); const RigFractureCell& stimPlanCell);
const std::vector<size_t>& globalIndeciesToContributingEclipseCells(); const std::vector<size_t>& globalIndeciesToContributingEclipseCells();
const std::vector<double>& contributingEclipseCellTransmissibilities(); const std::vector<double>& contributingEclipseCellTransmissibilities();
@ -51,7 +51,7 @@ private:
double m_cDarcy; double m_cDarcy;
double m_fractureSkinFactor; double m_fractureSkinFactor;
cvf::Mat4f m_fractureTransform; cvf::Mat4f m_fractureTransform;
const RigStimPlanFracTemplateCell& m_stimPlanCell; const RigFractureCell& m_stimPlanCell;
std::vector<size_t> m_globalIndeciesToContributingEclipseCells; std::vector<size_t> m_globalIndeciesToContributingEclipseCells;
std::vector<double> m_contributingEclipseCellTransmissibilities; std::vector<double> m_contributingEclipseCellTransmissibilities;

12
ApplicationCode/ReservoirDataModel/RigStimPlanFracTemplateCell.cpp → ApplicationCode/ReservoirDataModel/RigFractureCell.cpp
View File

@ -16,14 +16,14 @@
// //
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
#include "RigStimPlanFracTemplateCell.h" #include "RigFractureCell.h"
#include "RiaLogging.h" #include "RiaLogging.h"
#include <QString> #include <QString>
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigStimPlanFracTemplateCell::RigStimPlanFracTemplateCell() RigFractureCell::RigFractureCell()
{ {
} }
@ -31,7 +31,7 @@ RigStimPlanFracTemplateCell::RigStimPlanFracTemplateCell()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigStimPlanFracTemplateCell::RigStimPlanFracTemplateCell(std::vector<cvf::Vec3d> polygon, size_t i, size_t j) RigFractureCell::RigFractureCell(std::vector<cvf::Vec3d> polygon, size_t i, size_t j)
{ {
m_polygon = polygon; m_polygon = polygon;
m_i = i; m_i = i;
@ -41,7 +41,7 @@ RigStimPlanFracTemplateCell::RigStimPlanFracTemplateCell(std::vector<cvf::Vec3d>
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigStimPlanFracTemplateCell::~RigStimPlanFracTemplateCell() RigFractureCell::~RigFractureCell()
{ {
} }
@ -49,7 +49,7 @@ RigStimPlanFracTemplateCell::~RigStimPlanFracTemplateCell()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RigStimPlanFracTemplateCell::cellSizeX() const double RigFractureCell::cellSizeX() const
{ {
//The polygon corners are always stored in the same order //The polygon corners are always stored in the same order
if (m_polygon.size()>1) return (m_polygon[1] - m_polygon[0]).length(); if (m_polygon.size()>1) return (m_polygon[1] - m_polygon[0]).length();
@ -59,7 +59,7 @@ double RigStimPlanFracTemplateCell::cellSizeX() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RigStimPlanFracTemplateCell::cellSizeZ() const double RigFractureCell::cellSizeZ() const
{ {
if (m_polygon.size()>2) return (m_polygon[2] - m_polygon[1]).length(); if (m_polygon.size()>2) return (m_polygon[2] - m_polygon[1]).length();
return cvf::UNDEFINED_DOUBLE; return cvf::UNDEFINED_DOUBLE;

8
ApplicationCode/ReservoirDataModel/RigStimPlanFracTemplateCell.h → ApplicationCode/ReservoirDataModel/RigFractureCell.h
View File

@ -27,15 +27,15 @@
/// ///
/// ///
//================================================================================================== //==================================================================================================
class RigStimPlanFracTemplateCell class RigFractureCell
{ {
public: public:
RigStimPlanFracTemplateCell(); RigFractureCell();
RigStimPlanFracTemplateCell(std::vector<cvf::Vec3d> polygon, size_t i, size_t j); RigFractureCell(std::vector<cvf::Vec3d> polygon, size_t i, size_t j);
virtual ~RigStimPlanFracTemplateCell(); virtual ~RigFractureCell();
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; }

6
ApplicationCode/ReservoirDataModel/RigFractureGrid.cpp
View File

@ -39,11 +39,11 @@ size_t RigFractureGrid::getGlobalIndexFromIJ(size_t i, size_t j) const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RigStimPlanFracTemplateCell& RigFractureGrid::cellFromIndex(size_t index) const const RigFractureCell& RigFractureGrid::cellFromIndex(size_t index) const
{ {
if (index < m_fractureCells.size()) if (index < m_fractureCells.size())
{ {
const RigStimPlanFracTemplateCell& cell = m_fractureCells[index]; const RigFractureCell& cell = m_fractureCells[index];
return cell; return cell;
} }
else else
@ -51,7 +51,7 @@ const RigStimPlanFracTemplateCell& RigFractureGrid::cellFromIndex(size_t index)
//TODO: Better error handling? //TODO: Better error handling?
RiaLogging::error(QString("Requesting non-existent StimPlanCell")); RiaLogging::error(QString("Requesting non-existent StimPlanCell"));
RiaLogging::error(QString("Returning cell 0, results will be invalid")); RiaLogging::error(QString("Returning cell 0, results will be invalid"));
const RigStimPlanFracTemplateCell& cell = m_fractureCells[0]; const RigFractureCell& cell = m_fractureCells[0];
return cell; return cell;
} }
} }

24
ApplicationCode/ReservoirDataModel/RigFractureGrid.h
View File

@ -18,9 +18,9 @@
#pragma once #pragma once
#include "RigStimPlanFracTemplateCell.h" #include "RigFractureCell.h"
#include <vector> #include <vector>
class RigStimPlanFracTemplateCell; class RigFractureCell;
//================================================================================================== //==================================================================================================
/// ///
@ -31,25 +31,25 @@ class RigFractureGrid //TODO arve fra cvf::Object, skal v
public: public:
RigFractureGrid(); RigFractureGrid();
void setFractureCells(std::vector<RigStimPlanFracTemplateCell> fractureCells) { m_fractureCells = fractureCells; } void setFractureCells(std::vector<RigFractureCell> fractureCells) { m_fractureCells = fractureCells; }
void setWellCenterFractureCellIJ(std::pair<size_t, size_t> wellCenterFractureCellIJ) { m_wellCenterFractureCellIJ = wellCenterFractureCellIJ; } void setWellCenterFractureCellIJ(std::pair<size_t, size_t> wellCenterFractureCellIJ) { m_wellCenterFractureCellIJ = wellCenterFractureCellIJ; }
void setICellCount(size_t iCellCount) { m_iCellCount = iCellCount; } void setICellCount(size_t iCellCount) { m_iCellCount = iCellCount; }
void setJCellCount(size_t jCellCount) { m_jCellCount = jCellCount; } void setJCellCount(size_t jCellCount) { m_jCellCount = jCellCount; }
const std::vector<RigStimPlanFracTemplateCell>& fractureCells() const { return m_fractureCells; } const std::vector<RigFractureCell>& fractureCells() const { return m_fractureCells; }
size_t getGlobalIndexFromIJ(size_t i, size_t j) const; size_t getGlobalIndexFromIJ(size_t i, size_t j) const;
const RigStimPlanFracTemplateCell& cellFromIndex(size_t index) const; const RigFractureCell& cellFromIndex(size_t index) const;
size_t jCellCount() const { return m_jCellCount; } size_t jCellCount() const { return m_jCellCount; }
size_t iCellCount() const { return m_iCellCount; } size_t iCellCount() const { return m_iCellCount; }
std::pair<size_t, size_t> fractureCellAtWellCenter() const { return m_wellCenterFractureCellIJ; } std::pair<size_t, size_t> fractureCellAtWellCenter() const { return m_wellCenterFractureCellIJ; }
private: private:
std::vector<RigStimPlanFracTemplateCell> m_fractureCells; std::vector<RigFractureCell> m_fractureCells;
std::pair<size_t, size_t> m_wellCenterFractureCellIJ; std::pair<size_t, size_t> m_wellCenterFractureCellIJ;
size_t m_iCellCount; size_t m_iCellCount;
size_t m_jCellCount; size_t m_jCellCount;

2
ApplicationCode/ReservoirDataModel/RigFractureTransCalc.cpp
View File

@ -39,7 +39,7 @@
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "cvfMath.h" #include "cvfMath.h"
#include "RimDefines.h" #include "RimDefines.h"
#include "RigStimPlanFracTemplateCell.h" #include "RigFractureCell.h"
#include <cmath> //Used for log #include <cmath> //Used for log
#include "RiaApplication.h" #include "RiaApplication.h"
#include "RimEclipseView.h" #include "RimEclipseView.h"

2
ApplicationCode/ReservoirDataModel/RigFractureTransCalc.h
View File

@ -35,7 +35,7 @@
class RimFracture; class RimFracture;
class RimEclipseCase; class RimEclipseCase;
class RigStimPlanFracTemplateCell; class RigFractureCell;
class RimStimPlanFractureTemplate; class RimStimPlanFractureTemplate;
//================================================================================================== //==================================================================================================

28
ApplicationCode/ReservoirDataModel/RigStimPlanUpscalingCalc.cpp
View File

@ -4,7 +4,7 @@
#include "RigFractureTransCalc.h" #include "RigFractureTransCalc.h"
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigCellGeometryTools.h" #include "RigCellGeometryTools.h"
#include "RigStimPlanFracTemplateCell.h" #include "RigFractureCell.h"
#include "RiaLogging.h" #include "RiaLogging.h"
#include "RigFractureGrid.h" #include "RigFractureGrid.h"
@ -53,7 +53,7 @@ std::pair<double, double> RigStimPlanUpscalingCalc::flowAcrossLayersUpscaling(QS
} }
else return std::make_pair(cvf::UNDEFINED_DOUBLE, cvf::UNDEFINED_DOUBLE); else return std::make_pair(cvf::UNDEFINED_DOUBLE, cvf::UNDEFINED_DOUBLE);
std::vector<RigStimPlanFracTemplateCell> stimPlanCells = fracTemplateStimPlan->fractureGrid().fractureCells(); std::vector<RigFractureCell> stimPlanCells = fracTemplateStimPlan->fractureGrid().fractureCells();
@ -106,7 +106,7 @@ std::pair<double, double> RigStimPlanUpscalingCalc::flowAcrossLayersUpscaling(QS
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RigStimPlanUpscalingCalc::computeHAupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigStimPlanFracTemplateCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers) double RigStimPlanUpscalingCalc::computeHAupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigFractureCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers)
{ {
std::vector<double> DcolSum; std::vector<double> DcolSum;
std::vector<double> lavgCol; std::vector<double> lavgCol;
@ -118,8 +118,8 @@ double RigStimPlanUpscalingCalc::computeHAupscale(RimStimPlanFractureTemplate* f
std::vector<double> lengthsLiOfStimPlanCol; std::vector<double> lengthsLiOfStimPlanCol;
std::vector<double> heightsDiOfStimPlanCells; std::vector<double> heightsDiOfStimPlanCells;
std::vector<RigStimPlanFracTemplateCell*> stimPlanCellsCol = getColOfStimPlanCells(stimPlanCells, j); std::vector<RigFractureCell*> stimPlanCellsCol = getColOfStimPlanCells(stimPlanCells, j);
for (RigStimPlanFracTemplateCell* stimPlanCell : stimPlanCellsCol) for (RigFractureCell* stimPlanCell : stimPlanCellsCol)
{ {
if (stimPlanCell->getConductivtyValue() > 1e-7) if (stimPlanCell->getConductivtyValue() > 1e-7)
{ {
@ -175,7 +175,7 @@ double RigStimPlanUpscalingCalc::computeHAupscale(RimStimPlanFractureTemplate* f
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RigStimPlanUpscalingCalc::computeAHupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigStimPlanFracTemplateCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers) double RigStimPlanUpscalingCalc::computeAHupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigFractureCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers)
{ {
std::vector<double> DrowAvg; std::vector<double> DrowAvg;
std::vector<double> liRowSum; std::vector<double> liRowSum;
@ -187,8 +187,8 @@ double RigStimPlanUpscalingCalc::computeAHupscale(RimStimPlanFractureTemplate* f
std::vector<double> lengthsLiOfStimPlanCol; std::vector<double> lengthsLiOfStimPlanCol;
std::vector<double> heightsDiOfStimPlanCells; std::vector<double> heightsDiOfStimPlanCells;
std::vector<RigStimPlanFracTemplateCell*> stimPlanCellsCol = getRowOfStimPlanCells(stimPlanCells, j); std::vector<RigFractureCell*> stimPlanCellsCol = getRowOfStimPlanCells(stimPlanCells, j);
for (RigStimPlanFracTemplateCell* stimPlanCell : stimPlanCellsCol) for (RigFractureCell* stimPlanCell : stimPlanCellsCol)
{ {
if (stimPlanCell->getConductivtyValue() > 1e-7) if (stimPlanCell->getConductivtyValue() > 1e-7)
{ {
@ -320,11 +320,11 @@ std::vector<RigFracturedEclipseCellExportData> RigStimPlanUpscalingCalc::comput
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<RigStimPlanFracTemplateCell*> RigStimPlanUpscalingCalc::getRowOfStimPlanCells(std::vector<RigStimPlanFracTemplateCell>& allStimPlanCells, size_t i) std::vector<RigFractureCell*> RigStimPlanUpscalingCalc::getRowOfStimPlanCells(std::vector<RigFractureCell>& allStimPlanCells, size_t i)
{ {
std::vector<RigStimPlanFracTemplateCell*> stimPlanCellRow; std::vector<RigFractureCell*> stimPlanCellRow;
for (RigStimPlanFracTemplateCell stimPlanCell : allStimPlanCells) for (RigFractureCell stimPlanCell : allStimPlanCells)
{ {
if (stimPlanCell.getI() == i) if (stimPlanCell.getI() == i)
{ {
@ -338,11 +338,11 @@ std::vector<RigStimPlanFracTemplateCell*> RigStimPlanUpscalingCalc::getRowOfStim
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<RigStimPlanFracTemplateCell*> RigStimPlanUpscalingCalc::getColOfStimPlanCells(std::vector<RigStimPlanFracTemplateCell>& allStimPlanCells, size_t j) std::vector<RigFractureCell*> RigStimPlanUpscalingCalc::getColOfStimPlanCells(std::vector<RigFractureCell>& allStimPlanCells, size_t j)
{ {
std::vector<RigStimPlanFracTemplateCell*> stimPlanCellCol; std::vector<RigFractureCell*> stimPlanCellCol;
for (RigStimPlanFracTemplateCell stimPlanCell : allStimPlanCells) for (RigFractureCell stimPlanCell : allStimPlanCells)
{ {
if (stimPlanCell.getJ() == j) if (stimPlanCell.getJ() == j)
{ {

8
ApplicationCode/ReservoirDataModel/RigStimPlanUpscalingCalc.h
View File

@ -14,12 +14,12 @@ public:
private: private:
std::pair<double, double> flowAcrossLayersUpscaling(QString resultName, QString resultUnit, size_t timeStepIndex, RimDefines::UnitSystem unitSystem, size_t eclipseCellIndex); std::pair<double, double> flowAcrossLayersUpscaling(QString resultName, QString resultUnit, size_t timeStepIndex, RimDefines::UnitSystem unitSystem, size_t eclipseCellIndex);
double computeHAupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigStimPlanFracTemplateCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers); double computeHAupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigFractureCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers);
double computeAHupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigStimPlanFracTemplateCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers); double computeAHupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigFractureCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers);
static double arithmeticAverage(std::vector<double> values); static double arithmeticAverage(std::vector<double> values);
static std::vector<RigStimPlanFracTemplateCell*> getRowOfStimPlanCells(std::vector<RigStimPlanFracTemplateCell>& allStimPlanCells, size_t i); static std::vector<RigFractureCell*> getRowOfStimPlanCells(std::vector<RigFractureCell>& allStimPlanCells, size_t i);
static std::vector<RigStimPlanFracTemplateCell*> getColOfStimPlanCells(std::vector<RigStimPlanFracTemplateCell>& allStimPlanCells, size_t j); static std::vector<RigFractureCell*> getColOfStimPlanCells(std::vector<RigFractureCell>& allStimPlanCells, size_t j);
private: private:
RimEclipseCase* m_case; RimEclipseCase* m_case;

4
ApplicationCode/ReservoirDataModel/RigTransmissibilityCondenser.cpp
View File

@ -177,7 +177,7 @@ void RigTransmissibilityCondenser::calculateCondensedTransmissibilitiesIfNeeded(
#include "RimStimPlanFractureTemplate.h" #include "RimStimPlanFractureTemplate.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigStimPlanFracTemplateCell.h" #include "RigFractureCell.h"
void printCellAddress(std::stringstream& str, void printCellAddress(std::stringstream& str,
const RigMainGrid* mainGrid, const RigMainGrid* mainGrid,
@ -200,7 +200,7 @@ void printCellAddress(std::stringstream& str,
case CellAddress::STIMPLAN: case CellAddress::STIMPLAN:
{ {
str << "STP "; str << "STP ";
const RigStimPlanFracTemplateCell& stpCell = fractureGrid->fractureGrid().cellFromIndex(cellAddr.m_globalCellIdx); const RigFractureCell& stpCell = fractureGrid->fractureGrid().cellFromIndex(cellAddr.m_globalCellIdx);
str << std::setw(5) << stpCell.getI()+1 << std::setw(5) << stpCell.getJ()+1 << std::setw(5) << " "; str << std::setw(5) << stpCell.getI()+1 << std::setw(5) << stpCell.getJ()+1 << std::setw(5) << " ";
} }
break; break;

4
ApplicationCode/ReservoirDataModel/RigWellPathStimplanIntersector.cpp
View File

@ -5,7 +5,7 @@
#include "RimFractureTemplate.h" #include "RimFractureTemplate.h"
#include "cvfBase.h" #include "cvfBase.h"
#include "cvfMatrix4.h" #include "cvfMatrix4.h"
#include "RigStimPlanFracTemplateCell.h" #include "RigFractureCell.h"
#include "RimStimPlanFractureTemplate.h" #include "RimStimPlanFractureTemplate.h"
#include "RigFractureGrid.h" #include "RigFractureGrid.h"
@ -26,7 +26,7 @@ RigWellPathStimplanIntersector::RigWellPathStimplanIntersector(const RigWellPath
fracturePolygonf = stimPlanFractureTemplate->fracturePolygon(rimFracture->fractureUnit()); fracturePolygonf = stimPlanFractureTemplate->fracturePolygon(rimFracture->fractureUnit());
{ {
const std::vector<RigStimPlanFracTemplateCell>& stpCells = stimPlanFractureTemplate->fractureGrid().fractureCells(); const std::vector<RigFractureCell>& stpCells = stimPlanFractureTemplate->fractureGrid().fractureCells();
for ( const auto& stpCell: stpCells ) stpCellPolygons.push_back(stpCell.getPolygon()); for ( const auto& stpCell: stpCells ) stpCellPolygons.push_back(stpCell.getPolygon());
} }
} }

15
doc/fracture_clases.plantuml
View File

@ -23,18 +23,9 @@ class RigFracture{
std::vector<cvf::uint> m_triangleIndices; std::vector<cvf::uint> m_triangleIndices;
std::vector<cvf::Vec3f> m_nodeCoords; std::vector<cvf::Vec3f> m_nodeCoords;
std::vector<RigStimPlanFractureCell> m_stimPlanCellsFractureData;
}
class RigStimPlanFractureCell{
size_t m_i;
size_t m_j;
std::vector<size_t> globalIndeciesToContributingEclipseCells;
std::vector<double> contributingEclipseCellTransmisibilities;
} }
RimFracture *-- RigFracture RimFracture *-- RigFracture
RigFracture "1" *-- "n" RigStimPlanFractureCell
class RimFractureTemplate { class RimFractureTemplate {
todo...() todo...()
@ -58,7 +49,7 @@ class RigStimPlanFractureDefinition{
} }
class RigStimPlanFracTemplateCell{ class RigFractureCell{
std::vector<cvf::Vec3d> m_polygon; std::vector<cvf::Vec3d> m_polygon;
double m_displayValue; double m_displayValue;
double m_conductivityValue; double m_conductivityValue;
@ -74,9 +65,7 @@ class RigFractureGrid{
RimStimPlanFractureTemplate "1" *-- "1" RigStimPlanFractureDefinition RimStimPlanFractureTemplate "1" *-- "1" RigStimPlanFractureDefinition
RimStimPlanFractureTemplate "1" *-- "1" RigFractureGrid RimStimPlanFractureTemplate "1" *-- "1" RigFractureGrid
RigFractureGrid "1" *-- "many" RigStimPlanFracTemplateCell RigFractureGrid "1" *-- "many" RigFractureCell
RigStimPlanFractureCell <.> RigStimPlanFracTemplateCell
class RigStimPlanResultFrames{ class RigStimPlanResultFrames{
QString resultName; QString resultName;