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

6
ApplicationCode/ModelVisualization/RivWellFracturePartMgr.cpp
View File

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

6
ApplicationCode/ProjectDataModel/RimStimPlanFractureTemplate.cpp
View File

@ -26,7 +26,7 @@
#include "RimEclipseView.h"
#include "RimFracture.h"
#include "RimProject.h"
#include "RigStimPlanFracTemplateCell.h"
#include "RigFractureCell.h"
#include "RimStimPlanColors.h"
#include "RimStimPlanLegendConfig.h"
@ -820,7 +820,7 @@ void RimStimPlanFractureTemplate::setupStimPlanCells()
QString resultNameFromColors = activeView->stimPlanColors->resultName();
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);
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]), 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
{
stimPlanCell.setConductivityValue(conductivityValuesAtTimeStep[j + 1][i + 1]);

4
ApplicationCode/ProjectDataModel/RimStimPlanFractureTemplate.h
View File

@ -32,12 +32,12 @@
#include "cvfVector3.h"
#include <vector>
#include "RigStimPlanFracTemplateCell.h"
#include "RigFractureCell.h"
#include "RigFractureGrid.h"
class RigStimPlanFractureDefinition;
class RimStimPlanLegendConfig;
class RigStimPlanFracTemplateCell;
class RigFractureCell;
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}RigCellGeometryTools.h
${CEE_CURRENT_LIST_DIR}RigStimPlanFractureDefinition.h
${CEE_CURRENT_LIST_DIR}RigStimPlanFracTemplateCell.h
${CEE_CURRENT_LIST_DIR}RigStimPlanUpscalingCalc.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}RigCellGeometryTools.cpp
${CEE_CURRENT_LIST_DIR}RigStimPlanFractureDefinition.cpp
${CEE_CURRENT_LIST_DIR}RigStimPlanFracTemplateCell.cpp
${CEE_CURRENT_LIST_DIR}RigStimPlanUpscalingCalc.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 "RigStimPlanFracTemplateCell.h"
#include "RigFractureCell.h"
#include "RigResultAccessorFactory.h"
#include "RigEclipseCaseData.h"
#include "RigActiveCellInfo.h"
@ -40,7 +40,7 @@ RigEclipseToStimPlanCellTransmissibilityCalculator::RigEclipseToStimPlanCellTran
cvf::Mat4f fractureTransform,
double skinFactor,
double cDarcy,
const RigStimPlanFracTemplateCell& stimPlanCell)
const RigFractureCell& stimPlanCell)
: m_case(caseToApply),
m_fractureTransform(fractureTransform),
m_fractureSkinFactor(skinFactor),

6
ApplicationCode/ReservoirDataModel/RigEclipseToStimPlanCellTransmissibilityCalculator.h
View File

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

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

@ -27,15 +27,15 @@
///
///
//==================================================================================================
class RigStimPlanFracTemplateCell
class RigFractureCell
{
public:
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);
virtual ~RigStimPlanFracTemplateCell();
virtual ~RigFractureCell();
const std::vector<cvf::Vec3d>& getPolygon() const { return m_polygon; }
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())
{
const RigStimPlanFracTemplateCell& cell = m_fractureCells[index];
const RigFractureCell& cell = m_fractureCells[index];
return cell;
}
else
@ -51,7 +51,7 @@ const RigStimPlanFracTemplateCell& RigFractureGrid::cellFromIndex(size_t index)
//TODO: Better error handling?
RiaLogging::error(QString("Requesting non-existent StimPlanCell"));
RiaLogging::error(QString("Returning cell 0, results will be invalid"));
const RigStimPlanFracTemplateCell& cell = m_fractureCells[0];
const RigFractureCell& cell = m_fractureCells[0];
return cell;
}
}

24
ApplicationCode/ReservoirDataModel/RigFractureGrid.h
View File

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

2
ApplicationCode/ReservoirDataModel/RigFractureTransCalc.cpp
View File

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

2
ApplicationCode/ReservoirDataModel/RigFractureTransCalc.h
View File

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

28
ApplicationCode/ReservoirDataModel/RigStimPlanUpscalingCalc.cpp
View File

@ -4,7 +4,7 @@
#include "RigFractureTransCalc.h"
#include "RigEclipseCaseData.h"
#include "RigCellGeometryTools.h"
#include "RigStimPlanFracTemplateCell.h"
#include "RigFractureCell.h"
#include "RiaLogging.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);
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> lavgCol;
@ -118,8 +118,8 @@ double RigStimPlanUpscalingCalc::computeHAupscale(RimStimPlanFractureTemplate* f
std::vector<double> lengthsLiOfStimPlanCol;
std::vector<double> heightsDiOfStimPlanCells;
std::vector<RigStimPlanFracTemplateCell*> stimPlanCellsCol = getColOfStimPlanCells(stimPlanCells, j);
for (RigStimPlanFracTemplateCell* stimPlanCell : stimPlanCellsCol)
std::vector<RigFractureCell*> stimPlanCellsCol = getColOfStimPlanCells(stimPlanCells, j);
for (RigFractureCell* stimPlanCell : stimPlanCellsCol)
{
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> liRowSum;
@ -187,8 +187,8 @@ double RigStimPlanUpscalingCalc::computeAHupscale(RimStimPlanFractureTemplate* f
std::vector<double> lengthsLiOfStimPlanCol;
std::vector<double> heightsDiOfStimPlanCells;
std::vector<RigStimPlanFracTemplateCell*> stimPlanCellsCol = getRowOfStimPlanCells(stimPlanCells, j);
for (RigStimPlanFracTemplateCell* stimPlanCell : stimPlanCellsCol)
std::vector<RigFractureCell*> stimPlanCellsCol = getRowOfStimPlanCells(stimPlanCells, j);
for (RigFractureCell* stimPlanCell : stimPlanCellsCol)
{
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)
{
@ -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)
{

8
ApplicationCode/ReservoirDataModel/RigStimPlanUpscalingCalc.h
View File

@ -14,12 +14,12 @@ public:
private:
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 computeAHupscale(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<RigFractureCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers);
static double arithmeticAverage(std::vector<double> values);
static std::vector<RigStimPlanFracTemplateCell*> getRowOfStimPlanCells(std::vector<RigStimPlanFracTemplateCell>& allStimPlanCells, size_t i);
static std::vector<RigStimPlanFracTemplateCell*> getColOfStimPlanCells(std::vector<RigStimPlanFracTemplateCell>& allStimPlanCells, size_t j);
static std::vector<RigFractureCell*> getRowOfStimPlanCells(std::vector<RigFractureCell>& allStimPlanCells, size_t i);
static std::vector<RigFractureCell*> getColOfStimPlanCells(std::vector<RigFractureCell>& allStimPlanCells, size_t j);
private:
RimEclipseCase* m_case;

4
ApplicationCode/ReservoirDataModel/RigTransmissibilityCondenser.cpp
View File

@ -177,7 +177,7 @@ void RigTransmissibilityCondenser::calculateCondensedTransmissibilitiesIfNeeded(
#include "RimStimPlanFractureTemplate.h"
#include "RigMainGrid.h"
#include "RigStimPlanFracTemplateCell.h"
#include "RigFractureCell.h"
void printCellAddress(std::stringstream& str,
const RigMainGrid* mainGrid,
@ -200,7 +200,7 @@ void printCellAddress(std::stringstream& str,
case CellAddress::STIMPLAN:
{
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) << " ";
}
break;

4
ApplicationCode/ReservoirDataModel/RigWellPathStimplanIntersector.cpp
View File

@ -5,7 +5,7 @@
#include "RimFractureTemplate.h"
#include "cvfBase.h"
#include "cvfMatrix4.h"
#include "RigStimPlanFracTemplateCell.h"
#include "RigFractureCell.h"
#include "RimStimPlanFractureTemplate.h"
#include "RigFractureGrid.h"
@ -26,7 +26,7 @@ RigWellPathStimplanIntersector::RigWellPathStimplanIntersector(const RigWellPath
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());
}
}

15
doc/fracture_clases.plantuml
View File

@ -23,18 +23,9 @@ class RigFracture{
std::vector<cvf::uint> m_triangleIndices;
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
RigFracture "1" *-- "n" RigStimPlanFractureCell
class RimFractureTemplate {
todo...()
@ -58,7 +49,7 @@ class RigStimPlanFractureDefinition{
}
class RigStimPlanFracTemplateCell{
class RigFractureCell{
std::vector<cvf::Vec3d> m_polygon;
double m_displayValue;
double m_conductivityValue;
@ -74,9 +65,7 @@ class RigFractureGrid{
RimStimPlanFractureTemplate "1" *-- "1" RigStimPlanFractureDefinition
RimStimPlanFractureTemplate "1" *-- "1" RigFractureGrid
RigFractureGrid "1" *-- "many" RigStimPlanFracTemplateCell
RigStimPlanFractureCell <.> RigStimPlanFracTemplateCell
RigFractureGrid "1" *-- "many" RigFractureCell
class RigStimPlanResultFrames{
QString resultName;