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

pre-proto - Rename RigStimPlanCell to RigStimPlanFracTemplateCell

Browse Source
This commit is contained in:
astridkbjorke
2017-05-11 12:24:57 +02:00
parent 45321d0821
commit c6b329ea00
9 changed files with 73 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
ApplicationCode/FileInterface/RifEclipseExportTools.cpp
View File

@@ -42,7 +42,7 @@
#include "RigFractureTransCalc.h"
#include "RimFractureTemplate.h"
#include "RimStimPlanFractureTemplate.h"
#include "RigStimPlanCell.h"
#include "RigStimPlanFracTemplateCell.h"
#include "RimSimWellFracture.h"
@@ -279,9 +279,9 @@ void RifEclipseExportTools::printStimPlanCellsMatrixTransContributions(const std
RigFractureTransCalc transmissibilityCalculator(caseToApply, fracture);
std::vector<RigStimPlanCell> stimPlanCells = fracTemplateStimPlan->getStimPlanCells();
std::vector<RigStimPlanFracTemplateCell> stimPlanCells = fracTemplateStimPlan->getStimPlanCells();
for (RigStimPlanCell stimPlanCell : stimPlanCells)
for (RigStimPlanFracTemplateCell stimPlanCell : stimPlanCells)
{
if (stimPlanCell.getConductivtyValue() < 1e-7)
{
@@ -372,9 +372,9 @@ void RifEclipseExportTools::printStimPlanFractureTrans(const std::vector<RimFrac
}
else return;
std::vector<RigStimPlanCell> stimPlanCells = fracTemplateStimPlan->getStimPlanCells();
std::vector<RigStimPlanFracTemplateCell> stimPlanCells = fracTemplateStimPlan->getStimPlanCells();
for (RigStimPlanCell stimPlanCell : stimPlanCells)
for (RigStimPlanFracTemplateCell stimPlanCell : stimPlanCells)
{
if (stimPlanCell.getConductivtyValue() < 1e-7)
{
@@ -657,7 +657,7 @@ void RifEclipseExportTools::printTransmissibilityFractureToWell(const std::vecto
//RigStimPlanCell* stimPlanCell = fracTemplateStimPlan->getStimPlanCellAtIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second);
const RigStimPlanCell& stimPlanCell = fracTemplateStimPlan->stimPlanCellFromIndex(fracTemplateStimPlan->getGlobalIndexFromIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second));
const RigStimPlanFracTemplateCell& stimPlanCell = fracTemplateStimPlan->stimPlanCellFromIndex(fracTemplateStimPlan->getGlobalIndexFromIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second));
RigFractureTransCalc transmissibilityCalculator(caseToApply, fracture);
double RadTransInStimPlanCell = transmissibilityCalculator.computeLinearTransmissibilityToWellinStimPlanCell(stimPlanCell, perforationLengthVert, perforationLengthHor);
@@ -685,7 +685,7 @@ void RifEclipseExportTools::printTransmissibilityFractureToWell(const std::vecto
out << wellCenterStimPlanCellIJ.second;
//RigStimPlanCell* stimPlanCell = fracTemplateStimPlan->getStimPlanCellAtIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second);
const RigStimPlanCell& stimPlanCell = fracTemplateStimPlan->stimPlanCellFromIndex(fracTemplateStimPlan->getGlobalIndexFromIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second));
const RigStimPlanFracTemplateCell& stimPlanCell = fracTemplateStimPlan->stimPlanCellFromIndex(fracTemplateStimPlan->getGlobalIndexFromIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second));
//TODO: Error - stimPlanCell blir ikke riktig... Har ikke polygon!?!

6
ApplicationCode/ModelVisualization/RivWellFracturePartMgr.cpp
View File

@@ -25,7 +25,7 @@
#include "RimFracture.h"
#include "RimFractureTemplate.h"
#include "RimLegendConfig.h"
#include "RigStimPlanCell.h"
#include "RigStimPlanFracTemplateCell.h"
#include "RimStimPlanColors.h"
#include "RimStimPlanFractureTemplate.h"
@@ -288,10 +288,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<RigStimPlanCell> stimPlanCells = stimPlanFracTemplate->getStimPlanCells();
std::vector<RigStimPlanFracTemplateCell> stimPlanCells = stimPlanFracTemplate->getStimPlanCells();
std::vector<cvf::Vec3f> stimPlanMeshVertices;
for (RigStimPlanCell stimPlanCell : stimPlanCells)
for (RigStimPlanFracTemplateCell stimPlanCell : stimPlanCells)
{
if (stimPlanCell.getDisplayValue() > 1e-7)
{

14
ApplicationCode/ProjectDataModel/RimStimPlanFractureTemplate.cpp
View File

@@ -26,7 +26,7 @@
#include "RimEclipseView.h"
#include "RimFracture.h"
#include "RimProject.h"
#include "RigStimPlanCell.h"
#include "RigStimPlanFracTemplateCell.h"
#include "RimStimPlanColors.h"
#include "RimStimPlanLegendConfig.h"
@@ -819,7 +819,7 @@ void RimStimPlanFractureTemplate::setupStimPlanCells()
QString resultNameFromColors = activeView->stimPlanColors->resultName();
QString resultUnitFromColors = activeView->stimPlanColors->unit();
std::vector<RigStimPlanCell> stimPlanCells;
std::vector<RigStimPlanFracTemplateCell> stimPlanCells;
bool wellCenterStimPlanCellFound = false;
@@ -848,7 +848,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));
RigStimPlanCell stimPlanCell(cellPolygon, i, j);
RigStimPlanFracTemplateCell 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]);
@@ -895,7 +895,7 @@ void RimStimPlanFractureTemplate::setupStimPlanCells()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<RigStimPlanCell>& RimStimPlanFractureTemplate::getStimPlanCells()
const std::vector<RigStimPlanFracTemplateCell>& RimStimPlanFractureTemplate::getStimPlanCells()
{
return m_stimPlanCells;
}
@@ -968,11 +968,11 @@ size_t RimStimPlanFractureTemplate::getGlobalIndexFromIJ(size_t i, size_t j)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigStimPlanCell& RimStimPlanFractureTemplate::stimPlanCellFromIndex(size_t index) const
const RigStimPlanFracTemplateCell& RimStimPlanFractureTemplate::stimPlanCellFromIndex(size_t index) const
{
if (index < m_stimPlanCells.size())
{
const RigStimPlanCell& cell = m_stimPlanCells[index];
const RigStimPlanFracTemplateCell& cell = m_stimPlanCells[index];
return cell;
}
else
@@ -980,7 +980,7 @@ const RigStimPlanCell& RimStimPlanFractureTemplate::stimPlanCellFromIndex(size_t
//TODO: Better error handling?
RiaLogging::error("Requesting non-existent StimPlanCell");
RiaLogging::error("Returning cell 0, results will be invalid");
const RigStimPlanCell& cell = m_stimPlanCells[0];
const RigStimPlanFracTemplateCell& cell = m_stimPlanCells[0];
return cell;
}
}

8
ApplicationCode/ProjectDataModel/RimStimPlanFractureTemplate.h
View File

@@ -35,7 +35,7 @@
class RigStimPlanFractureDefinition;
class RimStimPlanLegendConfig;
class RigStimPlanCell;
class RigStimPlanFracTemplateCell;
//==================================================================================================
///
@@ -77,14 +77,14 @@ public:
void getStimPlanDataAsPolygonsAndValues(std::vector<std::vector<cvf::Vec3d> > &cellsAsPolygons, std::vector<double> &parameterValue, const QString& resultName, const QString& unitName, size_t timeStepIndex);
void setupStimPlanCells();
const std::vector<RigStimPlanCell>& getStimPlanCells();
const std::vector<RigStimPlanFracTemplateCell>& getStimPlanCells();
std::vector<cvf::Vec3d> getStimPlanRowPolygon(size_t i);
std::vector<cvf::Vec3d> getStimPlanColPolygon(size_t j);
std::pair<size_t, size_t> getStimPlanCellAtWellCenter();
size_t getGlobalIndexFromIJ(size_t i, size_t j); //TODO: should be const?
const RigStimPlanCell& stimPlanCellFromIndex(size_t index) const;
const RigStimPlanFracTemplateCell& stimPlanCellFromIndex(size_t index) const;
//TODO: Functions for finding perforated stimPlanCells
//Radial flow: Single cell (at 0,0)
@@ -122,6 +122,6 @@ private:
caf::PdmField<QString> m_stimPlanFileName;
cvf::ref<RigStimPlanFractureDefinition> m_stimPlanFractureDefinitionData;
std::vector<RigStimPlanCell> m_stimPlanCells;
std::vector<RigStimPlanFracTemplateCell> m_stimPlanCells;
std::pair<size_t, size_t> wellCenterStimPlanCellIJ;
};

36
ApplicationCode/ReservoirDataModel/RigFractureTransCalc.cpp
View File

@@ -39,7 +39,7 @@
#include "RigMainGrid.h"
#include "cvfMath.h"
#include "RimDefines.h"
#include "RigStimPlanCell.h"
#include "RigStimPlanFracTemplateCell.h"
#include <cmath> //Used for log
//--------------------------------------------------------------------------------------------------
@@ -246,7 +246,7 @@ void RigFractureTransCalc::computeTransmissibilityFromPolygonWithInfiniteConduct
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFractureTransCalc::calculateStimPlanCellsMatrixTransmissibility(RigStimPlanCell* stimPlanCell, RigStimPlanFractureCell* fracStimPlanCellData)
void RigFractureTransCalc::calculateStimPlanCellsMatrixTransmissibility(RigStimPlanFracTemplateCell* stimPlanCell, RigStimPlanFractureCell* fracStimPlanCellData)
{
//Not calculating flow into fracture if stimPlan cell cond value is 0 (assumed to be outside the fracture):
@@ -452,7 +452,7 @@ std::pair<double, double> RigFractureTransCalc::flowAcrossLayersUpscaling(QStrin
}
else return std::make_pair(cvf::UNDEFINED_DOUBLE, cvf::UNDEFINED_DOUBLE);
std::vector<RigStimPlanCell> stimPlanCells = fracTemplateStimPlan->getStimPlanCells();
std::vector<RigStimPlanFracTemplateCell> stimPlanCells = fracTemplateStimPlan->getStimPlanCells();
cvf::Vec3d localX, localY, localZ; //Not used in calculation here, but needed for function to find planCellPolygons
std::vector<std::vector<cvf::Vec3d> > planeCellPolygons;
@@ -507,7 +507,7 @@ std::pair<double, double> RigFractureTransCalc::flowAcrossLayersUpscaling(QStrin
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigFractureTransCalc::computeHAupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigStimPlanCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers)
double RigFractureTransCalc::computeHAupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigStimPlanFracTemplateCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers)
{
std::vector<double> DcolSum;
std::vector<double> lavgCol;
@@ -519,8 +519,8 @@ double RigFractureTransCalc::computeHAupscale(RimStimPlanFractureTemplate* fracT
std::vector<double> lengthsLiOfStimPlanCol;
std::vector<double> heightsDiOfStimPlanCells;
std::vector<RigStimPlanCell*> stimPlanCellsCol = getColOfStimPlanCells(stimPlanCells, j);
for (RigStimPlanCell* stimPlanCell : stimPlanCellsCol)
std::vector<RigStimPlanFracTemplateCell*> stimPlanCellsCol = getColOfStimPlanCells(stimPlanCells, j);
for (RigStimPlanFracTemplateCell* stimPlanCell : stimPlanCellsCol)
{
if (stimPlanCell->getConductivtyValue() > 1e-7)
{
@@ -576,7 +576,7 @@ double RigFractureTransCalc::computeHAupscale(RimStimPlanFractureTemplate* fracT
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigFractureTransCalc::computeAHupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigStimPlanCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers)
double RigFractureTransCalc::computeAHupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigStimPlanFracTemplateCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers)
{
std::vector<double> DrowAvg;
std::vector<double> liRowSum;
@@ -588,8 +588,8 @@ double RigFractureTransCalc::computeAHupscale(RimStimPlanFractureTemplate* fracT
std::vector<double> lengthsLiOfStimPlanCol;
std::vector<double> heightsDiOfStimPlanCells;
std::vector<RigStimPlanCell*> stimPlanCellsCol = getRowOfStimPlanCells(stimPlanCells, j);
for (RigStimPlanCell* stimPlanCell : stimPlanCellsCol)
std::vector<RigStimPlanFracTemplateCell*> stimPlanCellsCol = getRowOfStimPlanCells(stimPlanCells, j);
for (RigStimPlanFracTemplateCell* stimPlanCell : stimPlanCellsCol)
{
if (stimPlanCell->getConductivtyValue() > 1e-7)
{
@@ -728,7 +728,7 @@ void RigFractureTransCalc::computeUpscaledPropertyFromStimPlan( QString resultNa
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFractureTransCalc::computeStimPlanCellTransmissibilityInFracture(const RigStimPlanCell& stimPlanCell)
void RigFractureTransCalc::computeStimPlanCellTransmissibilityInFracture(const RigStimPlanFracTemplateCell& stimPlanCell)
{
double verticalSideLength = stimPlanCell.cellSizeX();
double horisontalSideLength = stimPlanCell.cellSizeZ();
@@ -743,7 +743,7 @@ void RigFractureTransCalc::computeStimPlanCellTransmissibilityInFracture(const R
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigFractureTransCalc::computeRadialTransmissibilityToWellinStimPlanCell(const RigStimPlanCell& stimPlanCell)
double RigFractureTransCalc::computeRadialTransmissibilityToWellinStimPlanCell(const RigStimPlanFracTemplateCell& stimPlanCell)
{
if (m_fracture->attachedFractureDefinition()->orientation == RimFractureTemplate::ALONG_WELL_PATH) return cvf::UNDEFINED_DOUBLE;
@@ -767,7 +767,7 @@ double RigFractureTransCalc::computeRadialTransmissibilityToWellinStimPlanCell(c
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigFractureTransCalc::computeLinearTransmissibilityToWellinStimPlanCell(const RigStimPlanCell& stimPlanCell, double perforationLengthVertical, double perforationLengthHorizontal)
double RigFractureTransCalc::computeLinearTransmissibilityToWellinStimPlanCell(const RigStimPlanFracTemplateCell& stimPlanCell, double perforationLengthVertical, double perforationLengthHorizontal)
{
double TcPrefix = 8 * cDarcy() * stimPlanCell.getConductivtyValue();
@@ -801,11 +801,11 @@ double RigFractureTransCalc::cDarcy()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RigStimPlanCell*> RigFractureTransCalc::getRowOfStimPlanCells(std::vector<RigStimPlanCell>& allStimPlanCells, size_t i)
std::vector<RigStimPlanFracTemplateCell*> RigFractureTransCalc::getRowOfStimPlanCells(std::vector<RigStimPlanFracTemplateCell>& allStimPlanCells, size_t i)
{
std::vector<RigStimPlanCell*> stimPlanCellRow;
std::vector<RigStimPlanFracTemplateCell*> stimPlanCellRow;
for (RigStimPlanCell stimPlanCell : allStimPlanCells)
for (RigStimPlanFracTemplateCell stimPlanCell : allStimPlanCells)
{
if (stimPlanCell.getI() == i)
{
@@ -819,11 +819,11 @@ std::vector<RigStimPlanCell*> RigFractureTransCalc::getRowOfStimPlanCells(std::v
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RigStimPlanCell*> RigFractureTransCalc::getColOfStimPlanCells(std::vector<RigStimPlanCell>& allStimPlanCells, size_t j)
std::vector<RigStimPlanFracTemplateCell*> RigFractureTransCalc::getColOfStimPlanCells(std::vector<RigStimPlanFracTemplateCell>& allStimPlanCells, size_t j)
{
std::vector<RigStimPlanCell*> stimPlanCellCol;
std::vector<RigStimPlanFracTemplateCell*> stimPlanCellCol;
for (RigStimPlanCell stimPlanCell : allStimPlanCells)
for (RigStimPlanFracTemplateCell stimPlanCell : allStimPlanCells)
{
if (stimPlanCell.getJ() == j)
{

18
ApplicationCode/ReservoirDataModel/RigFractureTransCalc.h
View File

@@ -34,7 +34,7 @@
class RimFracture;
class RimEclipseCase;
class RigStimPlanCell;
class RigStimPlanFracTemplateCell;
class RimStimPlanFractureTemplate;
class RigStimPlanFractureCell;
@@ -54,18 +54,18 @@ public:
// Obsolete if final calculations will be done on the stimPlan grid
void computeUpscaledPropertyFromStimPlan(QString resultName, QString resultUnit, size_t timeStepIndex);
std::pair<double, double> flowAcrossLayersUpscaling(QString resultName, QString resultUnit, size_t timeStepIndex, RimDefines::UnitSystem unitSystem, size_t eclipseCellIndex);
double computeHAupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigStimPlanCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers);
double computeAHupscale(RimStimPlanFractureTemplate* fracTemplateStimPlan, std::vector<RigStimPlanCell> stimPlanCells, std::vector<cvf::Vec3d> planeCellPolygon, cvf::Vec3d directionAlongLayers, cvf::Vec3d directionAcrossLayers);
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);
static double arithmeticAverage(std::vector<double> values);
// Calculations based on StimPlan grid
void calculateStimPlanCellsMatrixTransmissibility(RigStimPlanCell* stimPlanCell, RigStimPlanFractureCell* fracStimPlanCellData);
static void computeStimPlanCellTransmissibilityInFracture(const RigStimPlanCell& stimPlanCell);
double computeRadialTransmissibilityToWellinStimPlanCell(const RigStimPlanCell& stimPlanCell);
double computeLinearTransmissibilityToWellinStimPlanCell(const RigStimPlanCell& stimPlanCell, double perforationLengthVertical, double perforationLengthHorizontal);
void calculateStimPlanCellsMatrixTransmissibility(RigStimPlanFracTemplateCell* stimPlanCell, RigStimPlanFractureCell* fracStimPlanCellData);
static void computeStimPlanCellTransmissibilityInFracture(const RigStimPlanFracTemplateCell& stimPlanCell);
double computeRadialTransmissibilityToWellinStimPlanCell(const RigStimPlanFracTemplateCell& stimPlanCell);
double computeLinearTransmissibilityToWellinStimPlanCell(const RigStimPlanFracTemplateCell& stimPlanCell, double perforationLengthVertical, double perforationLengthHorizontal);
static std::vector<RigStimPlanCell*> getRowOfStimPlanCells(std::vector<RigStimPlanCell>& allStimPlanCells, size_t i);
static std::vector<RigStimPlanCell*> getColOfStimPlanCells(std::vector<RigStimPlanCell>& allStimPlanCells, size_t j);
static std::vector<RigStimPlanFracTemplateCell*> getRowOfStimPlanCells(std::vector<RigStimPlanFracTemplateCell>& allStimPlanCells, size_t i);
static std::vector<RigStimPlanFracTemplateCell*> getColOfStimPlanCells(std::vector<RigStimPlanFracTemplateCell>& allStimPlanCells, size_t j);
private:
double convertConductivtyValue(double Kw, RimDefines::UnitSystem fromUnit, RimDefines::UnitSystem toUnit);

14
ApplicationCode/ReservoirDataModel/RigStimPlanCell.cpp → ApplicationCode/ReservoirDataModel/RigStimPlanFracTemplateCell.cpp
View File

@@ -16,12 +16,12 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RigStimPlanCell.h"
#include "RigStimPlanFracTemplateCell.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigStimPlanCell::RigStimPlanCell()
RigStimPlanFracTemplateCell::RigStimPlanFracTemplateCell()
{
}
@@ -29,7 +29,7 @@ RigStimPlanCell::RigStimPlanCell()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigStimPlanCell::RigStimPlanCell(std::vector<cvf::Vec3d> polygon, size_t i, size_t j)
RigStimPlanFracTemplateCell::RigStimPlanFracTemplateCell(std::vector<cvf::Vec3d> polygon, size_t i, size_t j)
{
m_polygon = polygon;
m_i = i;
@@ -39,7 +39,7 @@ RigStimPlanCell::RigStimPlanCell(std::vector<cvf::Vec3d> polygon, size_t i, size
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigStimPlanCell::~RigStimPlanCell()
RigStimPlanFracTemplateCell::~RigStimPlanFracTemplateCell()
{
}
@@ -47,7 +47,7 @@ RigStimPlanCell::~RigStimPlanCell()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigStimPlanCell::setTransmissibilityInFracture(double valueHorizontal, double valueVertical)
void RigStimPlanFracTemplateCell::setTransmissibilityInFracture(double valueHorizontal, double valueVertical)
{
m_transmissibilityInFractureHorizontal = valueHorizontal;
m_transmissibilityInFractureVertical = valueVertical;
@@ -56,7 +56,7 @@ void RigStimPlanCell::setTransmissibilityInFracture(double valueHorizontal, doub
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigStimPlanCell::cellSizeX() const
double RigStimPlanFracTemplateCell::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();
@@ -66,7 +66,7 @@ double RigStimPlanCell::cellSizeX() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigStimPlanCell::cellSizeZ() const
double RigStimPlanFracTemplateCell::cellSizeZ() const
{
if (m_polygon.size()>2) return (m_polygon[2] - m_polygon[1]).length();
return cvf::UNDEFINED_DOUBLE;

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

@@ -27,15 +27,15 @@
///
///
//==================================================================================================
class RigStimPlanCell
class RigStimPlanFracTemplateCell
{
public:
RigStimPlanCell();
RigStimPlanCell(std::vector<cvf::Vec3d> polygon, size_t i, size_t j);
RigStimPlanFracTemplateCell();
RigStimPlanFracTemplateCell(std::vector<cvf::Vec3d> polygon, size_t i, size_t j);
virtual ~RigStimPlanCell();
virtual ~RigStimPlanFracTemplateCell();
std::vector<cvf::Vec3d> getPolygon() { return m_polygon; }
double getConductivtyValue() const { return m_concutivityValue; }

21
doc/fracture_clases.plantuml
View File

@@ -23,10 +23,10 @@ class RigFracture{
std::vector<cvf::uint> m_triangleIndices;
std::vector<cvf::Vec3f> m_nodeCoords;
std::vector<RigFractureStimPlanCellData> m_stimPlanCellsFractureData;
std::vector<RigStimPlanFractureCell> m_stimPlanCellsFractureData;
}
class RigFractureStimPlanCellData{
class RigStimPlanFractureCell{
size_t m_i;
size_t m_j;
std::vector<size_t> contributingEclipseCells;
@@ -34,7 +34,7 @@ class RigFractureStimPlanCellData{
}
RimFracture *-- RigFracture
RigFracture "1" *-- "n" RigFractureStimPlanCellData
RigFracture "1" *-- "n" RigStimPlanFractureCell
class RimFractureTemplate {
todo...()
@@ -57,7 +57,8 @@ class RigStimPlanFractureDefinition{
std::vector<RigStimPlanData> stimPlanData;
}
class RigStimPlanCell{
class RigStimPlanFracTemplateCell{
std::vector<cvf::Vec3d> m_polygon;
double m_displayValue;
double m_conductivityValue;
@@ -69,9 +70,9 @@ class RigStimPlanCell{
}
RimStimPlanFractureTemplate "1" *-- "1" RigStimPlanFractureDefinition
RimStimPlanFractureTemplate "1" *-- "many" RigStimPlanCell
RimStimPlanFractureTemplate "1" *-- "many" RigStimPlanFracTemplateCell
RigFractureStimPlanCellData <..> RigStimPlanCell
RigStimPlanFractureCell <..> RigStimPlanFracTemplateCell
class RigStimPlanData{
QString resultName;
@@ -92,7 +93,7 @@ class RigFractureTransCalc{
RimFracture ..|> RigFractureTransCalc
RigStimPlanCell ..|> RigFractureTransCalc
RigFractureStimPlanCellData ..|> RigFractureTransCalc
RigStimPlanFractureCell ..|> RigFractureTransCalc
class RifEclipseExportTools{
@@ -100,4 +101,10 @@ class RifEclipseExportTools{
RigFractureTransCalc ..|> RifEclipseExportTools
class FunctionsForIterations{
}
@enduml