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 - Cleanups in code. Renamings and adding functions global index in array of RigStimPlanCell for simplified interaction with these

Browse Source
This commit is contained in:
astridkbjorke
2017-04-25 16:08:44 +02:00
parent 777384b735
commit a5e3e864fb
9 changed files with 144 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
ApplicationCode/FileInterface/RifEclipseExportTools.cpp
View File

@@ -119,7 +119,7 @@ bool RifEclipseExportTools::writeFracturesToTextFile(const QString& fileName, c
RigFractureTransCalc transmissibilityCalculator(caseToApply, fracture);
//TODO: Check that there is a fracture template available for given fracture....
transmissibilityCalculator.computeTransmissibility();
transmissibilityCalculator.computeTransmissibilityFromPolygonWithInfiniteConductivityInFracture();
std::vector<RigFractureData> fracDataVector = fracture->attachedRigFracture()->fractureData();
for (RigFractureData fracData : fracDataVector)
@@ -335,6 +335,8 @@ void RifEclipseExportTools::printStimPlanCellsMatrixTransContributions(const std
out << "\n";
}
//TODO: add RigFractureStimPlanCellData to m_StimPlanCellsFractureData i RigFracture???
}
}
return;
@@ -380,7 +382,7 @@ void RifEclipseExportTools::printStimPlanFractureTrans(const std::vector<RimFrac
continue;
}
RigFractureTransCalc::computeStimPlanCellTransmissibilityInFracture(&stimPlanCell);
RigFractureTransCalc::computeStimPlanCellTransmissibilityInFracture(stimPlanCell);
out << qSetFieldWidth(5);
size_t spi = stimPlanCell.getI();
@@ -593,7 +595,21 @@ void RifEclipseExportTools::printBackgroundData(QTextStream & out, RimWellPath*
//--------------------------------------------------------------------------------------------------
void RifEclipseExportTools::printTransmissibilityFractureToWell(const std::vector<RimFracture *>& fractures, QTextStream &out, RimEclipseCase* caseToApply)
{
out << "Transmissibility From Fracture To Well \n";
out << "-- Transmissibility From Fracture To Well \n";
out << qSetFieldWidth(12);
out << "Well name ";
out << qSetFieldWidth(16);
out << "Fracture name ";
out << "Inflow type ";
out << qSetFieldWidth(5);
out << " i ";
out << " j ";
out << "Tw";
out << "\n";
for (RimFracture* fracture : fractures)
{
@@ -609,11 +625,10 @@ void RifEclipseExportTools::printTransmissibilityFractureToWell(const std::vecto
out << fracture->name().left(15) + " ";
if (fracture->attachedFractureDefinition()->orientation == RimFractureTemplate::ALONG_WELL_PATH)
{
out << "Linear inflow";
out << qSetFieldWidth(5);
RimStimPlanFractureTemplate* fracTemplateStimPlan;
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracture->attachedFractureDefinition()))
@@ -634,25 +649,24 @@ void RifEclipseExportTools::printTransmissibilityFractureToWell(const std::vecto
double perforationLengthVert = fracture->perforationLength * cos(wellDip);
double perforationLengthHor = fracture->perforationLength * sin(wellDip);
RigStimPlanCell* stimPlanCell = fracTemplateStimPlan->getStimPlanCellAtWell();
//TODO: Error in getting the StimPlanWellCell here!!!
std::pair<size_t, size_t> wellCenterStimPlanCellIJ = fracTemplateStimPlan->getStimPlanCellAtWellCenter();
out << qSetFieldWidth(5);
out << wellCenterStimPlanCellIJ.first;
out << wellCenterStimPlanCellIJ.second;
out << stimPlanCell->getI();
out << stimPlanCell->getJ();
//TODO: Check if perforation length is larger than cell - expand to neightbour cells if needed!
//RigStimPlanCell* stimPlanCell = fracTemplateStimPlan->getStimPlanCellAtIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second);
const RigStimPlanCell& stimPlanCell = fracTemplateStimPlan->stimPlanCellFromIndex(fracTemplateStimPlan->getGlobalIndexFromIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second));
RigFractureTransCalc transmissibilityCalculator(caseToApply, fracture);
double RadTransInStimPlanCell = transmissibilityCalculator.computeLinearTransmissibilityToWellinStimPlanCell(stimPlanCell, perforationLengthVert, perforationLengthHor);
out << RadTransInStimPlanCell;
out << "\n";
}
if (fracture->attachedFractureDefinition()->orientation == RimFractureTemplate::TRANSVERSE_WELL_PATH
|| fracture->attachedFractureDefinition()->orientation == RimFractureTemplate::AZIMUTH)
{
@@ -665,16 +679,22 @@ void RifEclipseExportTools::printTransmissibilityFractureToWell(const std::vecto
}
else continue;
RigStimPlanCell* stimPlanCell = fracTemplateStimPlan->getStimPlanCellAtWell();
//TODO: Error in getting the StimPlanWellCell here!!!
std::pair<size_t, size_t> wellCenterStimPlanCellIJ = fracTemplateStimPlan->getStimPlanCellAtWellCenter();
out << qSetFieldWidth(5);
out << wellCenterStimPlanCellIJ.first;
out << wellCenterStimPlanCellIJ.second;
out << stimPlanCell->getI();
out << stimPlanCell->getJ();
//RigStimPlanCell* stimPlanCell = fracTemplateStimPlan->getStimPlanCellAtIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second);
const RigStimPlanCell& stimPlanCell = fracTemplateStimPlan->stimPlanCellFromIndex(fracTemplateStimPlan->getGlobalIndexFromIJ(wellCenterStimPlanCellIJ.first, wellCenterStimPlanCellIJ.second));
//TODO: Error - stimPlanCell blir ikke riktig... Har ikke polygon!?!
RigFractureTransCalc transmissibilityCalculator(caseToApply, fracture);
double RadTransInStimPlanCell = transmissibilityCalculator.computeRadialTransmissibilityToWellinStimPlanCell(stimPlanCell);
out << RadTransInStimPlanCell;
out << "\n";
}
@@ -682,4 +702,5 @@ void RifEclipseExportTools::printTransmissibilityFractureToWell(const std::vecto
}
out << "\n";
}

2
ApplicationCode/FileInterface/RifEclipseExportTools.h
View File

@@ -54,6 +54,7 @@ public:
static void performStimPlanUpscalingAndPrintResults(const std::vector<RimFracture *>& fractures, RimEclipseCase* caseToApply, QTextStream &out, RimWellPath* wellPath, RimEclipseWell* simWell, const RigMainGrid* mainGrid);
static void printStimPlanCellsMatrixTransContributions(const std::vector<RimFracture *>& fractures, RimEclipseCase* caseToApply, QTextStream &out, RimWellPath* wellPath, RimEclipseWell* simWell, const RigMainGrid* mainGrid);
static void printStimPlanFractureTrans(const std::vector<RimFracture *>& fractures, QTextStream &out);
static void printTransmissibilityFractureToWell(const std::vector<RimFracture *>& fractures, QTextStream &out, RimEclipseCase* caseToApply);
static void printCOMPDATvalues(QTextStream & out, RigFractureData &fracData, RimFracture* fracture, RimWellPath* wellPath, RimEclipseWell* simWell, const RigMainGrid* mainGrid);
@@ -64,5 +65,4 @@ public:
private:
static void printTransmissibilityFractureToWell(const std::vector<RimFracture *>& fractures, QTextStream &out, RimEclipseCase* caseToApply);
};

72
ApplicationCode/ProjectDataModel/RimStimPlanFractureTemplate.cpp
View File

@@ -65,8 +65,10 @@ RimStimPlanFractureTemplate::RimStimPlanFractureTemplate(void)
CAF_PDM_InitField(&parameterForPolygon, "parameterForPolyton", QString(""), "Parameter", "", "", "");
CAF_PDM_InitField(&activeTimeStepIndex, "activeTimeStepIndex", 0, "Active TimeStep Index", "", "", "");
CAF_PDM_InitField(&showStimPlanMesh, "showStimPlanMesh", true, "Show StimPlan Mesh", "", "", "")
CAF_PDM_InitField(&showStimPlanMesh, "showStimPlanMesh", true, "Show StimPlan Mesh", "", "", "");
//TODO: Is this correct way of doing this...?
wellCenterStimPlanCellIJ = std::make_pair(0, 0);
}
//--------------------------------------------------------------------------------------------------
@@ -818,7 +820,8 @@ void RimStimPlanFractureTemplate::setupStimPlanCells()
QString resultUnitFromColors = activeView->stimPlanColors->unit();
std::vector<RigStimPlanCell> stimPlanCells;
wellCenterStimPlanCell = nullptr;
bool wellCenterStimPlanCellFound = false;
std::vector<std::vector<double>> displayPropertyValuesAtTimeStep = getMirroredDataAtTimeIndex(resultNameFromColors, resultUnitFromColors, activeTimeStepIndex);
@@ -835,20 +838,20 @@ void RimStimPlanFractureTemplate::setupStimPlanCells()
std::vector<double> depthCoords;
for (int i = 0; i < depthCoordsAtNodes.size() - 1; i++) depthCoords.push_back((depthCoordsAtNodes[i] + depthCoordsAtNodes[i + 1]) / 2);
for (int j = 0; j < xCoords.size() - 1; j++)
for (int i = 0; i < xCoords.size() - 1; i++)
{
for (int i = 0; i < depthCoords.size() - 1; i++)
for (int j = 0; j < depthCoords.size() - 1; j++)
{
std::vector<cvf::Vec3d> cellPolygon;
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[j]), static_cast<float>(depthCoords[i]), 0.0));
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[j + 1]), static_cast<float>(depthCoords[i]), 0.0));
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[j + 1]), static_cast<float>(depthCoords[i + 1]), 0.0));
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[j]), static_cast<float>(depthCoords[i + 1]), 0.0));
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[i]), static_cast<float>(depthCoords[j]), 0.0));
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[i + 1]), static_cast<float>(depthCoords[j]), 0.0));
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[i + 1]), static_cast<float>(depthCoords[j + 1]), 0.0));
cellPolygon.push_back(cvf::Vec3d(static_cast<float>(xCoords[i]), static_cast<float>(depthCoords[j + 1]), 0.0));
RigStimPlanCell stimPlanCell(cellPolygon, i, j);
if (conductivityValuesAtTimeStep.size() > 0) //Assuming vector to be of correct length, or no values
{
stimPlanCell.setConductivityValue(conductivityValuesAtTimeStep[i + 1][j + 1]);
stimPlanCell.setConductivityValue(conductivityValuesAtTimeStep[j + 1][i + 1]);
}
else
{
@@ -857,7 +860,7 @@ void RimStimPlanFractureTemplate::setupStimPlanCells()
if (displayPropertyValuesAtTimeStep.size() > 0)
{
stimPlanCell.setDisplayValue(displayPropertyValuesAtTimeStep[i + 1][j + 1]);
stimPlanCell.setDisplayValue(displayPropertyValuesAtTimeStep[j + 1][i + 1]);
}
else
{
@@ -866,9 +869,13 @@ void RimStimPlanFractureTemplate::setupStimPlanCells()
if (cellPolygon[0].x() < 0.0 && cellPolygon[1].x() > 0.0)
{
if (cellPolygon[1].y() < 0.0 && cellPolygon[2].y() > 0.0)
if (cellPolygon[1].y() > 0.0 && cellPolygon[2].y() < 0.0)
{
wellCenterStimPlanCell = &stimPlanCell;
wellCenterStimPlanCellIJ = std::make_pair(stimPlanCell.getI(), stimPlanCell.getJ());
RiaLogging::debug(QString("Setting wellCenterStimPlanCell at cell %1, %2").
arg(QString::number(stimPlanCell.getI()), QString::number(stimPlanCell.getJ())));
wellCenterStimPlanCellFound = true;
}
}
@@ -876,6 +883,12 @@ void RimStimPlanFractureTemplate::setupStimPlanCells()
}
}
if (!wellCenterStimPlanCellFound)
{
RiaLogging::error("Did not find stim plan cell at well crossing!");
}
m_stimPlanCells = stimPlanCells;
}
@@ -936,9 +949,40 @@ std::vector<cvf::Vec3d> RimStimPlanFractureTemplate::getStimPlanColPolygon(size_
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigStimPlanCell* RimStimPlanFractureTemplate::getStimPlanCellAtWell()
std::pair<size_t, size_t> RimStimPlanFractureTemplate::getStimPlanCellAtWellCenter()
{
return wellCenterStimPlanCell;
return wellCenterStimPlanCellIJ;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RimStimPlanFractureTemplate::getGlobalIndexFromIJ(size_t i, size_t j)
{
size_t length_I = stimPlanGridNumberOfRows() - 1;
size_t globIndex = j * length_I + i;
return globIndex;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigStimPlanCell& RimStimPlanFractureTemplate::stimPlanCellFromIndex(size_t index) const
{
if (index < m_stimPlanCells.size())
{
const RigStimPlanCell& cell = m_stimPlanCells[index];
return cell;
}
else
{
//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];
return cell;
}
}
//--------------------------------------------------------------------------------------------------

8
ApplicationCode/ProjectDataModel/RimStimPlanFractureTemplate.h
View File

@@ -81,7 +81,10 @@ public:
std::vector<cvf::Vec3d> getStimPlanRowPolygon(size_t i);
std::vector<cvf::Vec3d> getStimPlanColPolygon(size_t j);
RigStimPlanCell* getStimPlanCellAtWell();
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;
//TODO: Functions for finding perforated stimPlanCells
//Radial flow: Single cell (at 0,0)
@@ -96,6 +99,7 @@ public:
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly) override;
protected:
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering);
virtual void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute * attribute) override;
@@ -119,5 +123,5 @@ private:
caf::PdmField<QString> m_stimPlanFileName;
cvf::ref<RigStimPlanFractureDefinition> m_stimPlanFractureDefinitionData;
std::vector<RigStimPlanCell> m_stimPlanCells;
RigStimPlanCell* wellCenterStimPlanCell;
std::pair<size_t, size_t> wellCenterStimPlanCellIJ;
};

7
ApplicationCode/ReservoirDataModel/RigFracture.h
View File

@@ -65,6 +65,9 @@ public:
void addContributingEclipseCell(size_t eclipseCell, double transmissibility);
private:
double performationLenghtVertical;
double performationLenghtHorizontal;
std::vector<size_t> contributingEclipseCells;
std::vector<double> contributingEclipseCellTransmisibilities;
@@ -90,10 +93,12 @@ public:
std::vector<RigFractureData> m_fractureData;
void addStimPlanCellFractureCell(RigFractureStimPlanCellData fracStimPlanCellData);
private:
std::vector<cvf::uint> m_triangleIndices;
std::vector<cvf::Vec3f> m_nodeCoords;
std::vector<RigFractureStimPlanCellData> m_stimPlanCellsFractureData;
std::vector<RigFractureStimPlanCellData> m_stimPlanCellsFractureData;
std::vector<size_t> m_perforatedStimPlanCellsIndex;
};

29
ApplicationCode/ReservoirDataModel/RigFractureTransCalc.cpp
View File

@@ -80,7 +80,7 @@ RigFractureTransCalc::RigFractureTransCalc(RimEclipseCase* caseToApply, RimFract
//--------------------------------------------------------------------------------------------------
/// TODO: Document equation
//--------------------------------------------------------------------------------------------------
void RigFractureTransCalc::computeTransmissibility()
void RigFractureTransCalc::computeTransmissibilityFromPolygonWithInfiniteConductivityInFracture()
{
if (m_fracture->attachedFractureDefinition()->fractureConductivity == RimFractureTemplate::FINITE_CONDUCTIVITY)
{
@@ -728,21 +728,22 @@ void RigFractureTransCalc::computeUpscaledPropertyFromStimPlan( QString resultNa
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFractureTransCalc::computeStimPlanCellTransmissibilityInFracture(RigStimPlanCell* stimPlanCell)
void RigFractureTransCalc::computeStimPlanCellTransmissibilityInFracture(const RigStimPlanCell& stimPlanCell)
{
double verticalSideLength = stimPlanCell->cellSizeX();
double horisontalSideLength = stimPlanCell->cellSizeZ();
double verticalSideLength = stimPlanCell.cellSizeX();
double horisontalSideLength = stimPlanCell.cellSizeZ();
double verticalTrans = stimPlanCell->getConductivtyValue() * verticalSideLength / (horisontalSideLength / 2);
double horizontalTrans = stimPlanCell->getConductivtyValue() * horisontalSideLength / (verticalSideLength / 2);
double verticalTrans = stimPlanCell.getConductivtyValue() * verticalSideLength / (horisontalSideLength / 2);
double horizontalTrans = stimPlanCell.getConductivtyValue() * horisontalSideLength / (verticalSideLength / 2);
stimPlanCell->setTransmissibilityInFracture(verticalTrans, horizontalTrans);
//TODO: Ta bort const???
// stimPlanCell.setTransmissibilityInFracture(verticalTrans, horizontalTrans);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigFractureTransCalc::computeRadialTransmissibilityToWellinStimPlanCell(RigStimPlanCell* stimPlanCell)
double RigFractureTransCalc::computeRadialTransmissibilityToWellinStimPlanCell(const RigStimPlanCell& stimPlanCell)
{
if (m_fracture->attachedFractureDefinition()->orientation == RimFractureTemplate::ALONG_WELL_PATH) return cvf::UNDEFINED_DOUBLE;
@@ -753,9 +754,9 @@ double RigFractureTransCalc::computeRadialTransmissibilityToWellinStimPlanCell(R
}
double ro = 0.14 * cvf::Math::sqrt(
pow(stimPlanCell->cellSizeX(), 2.0) + pow(stimPlanCell->cellSizeZ(), 2));
pow(stimPlanCell.cellSizeX(), 2.0) + pow(stimPlanCell.cellSizeZ(), 2));
double Tc = 2 * cvf::PI_D * cDarcy() * stimPlanCell->getConductivtyValue() /
double Tc = 2 * cvf::PI_D * cDarcy() * stimPlanCell.getConductivtyValue() /
(log(ro / m_fracture->wellRadius()) + m_fracture->attachedFractureDefinition()->skinFactor() );
Tc = Tc * areaScalingFactor;
@@ -766,18 +767,18 @@ double RigFractureTransCalc::computeRadialTransmissibilityToWellinStimPlanCell(R
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigFractureTransCalc::computeLinearTransmissibilityToWellinStimPlanCell(RigStimPlanCell* stimPlanCell, double perforationLengthVertical, double perforationLengthHorizontal)
double RigFractureTransCalc::computeLinearTransmissibilityToWellinStimPlanCell(const RigStimPlanCell& stimPlanCell, double perforationLengthVertical, double perforationLengthHorizontal)
{
double TcPrefix = 8 * cDarcy() * stimPlanCell->getConductivtyValue();
double TcPrefix = 8 * cDarcy() * stimPlanCell.getConductivtyValue();
double DzPerf = perforationLengthVertical * m_fracture->perforationEfficiency();
double DxPerf = perforationLengthHorizontal * m_fracture->perforationEfficiency();
double TcZ = TcPrefix * DzPerf /
(stimPlanCell->cellSizeX() + m_fracture->attachedFractureDefinition()->skinFactor() * DzPerf / cvf::PI_D);
(stimPlanCell.cellSizeX() + m_fracture->attachedFractureDefinition()->skinFactor() * DzPerf / cvf::PI_D);
double TcX = TcPrefix * DxPerf /
(stimPlanCell->cellSizeZ() + m_fracture->attachedFractureDefinition()->skinFactor() * DxPerf / cvf::PI_D);
(stimPlanCell.cellSizeZ() + m_fracture->attachedFractureDefinition()->skinFactor() * DxPerf / cvf::PI_D);
double Tc = cvf::Math::sqrt(pow(TcX, 2) + pow(TcZ, 2));
return Tc;

21
ApplicationCode/ReservoirDataModel/RigFractureTransCalc.h
View File

@@ -46,25 +46,23 @@ class RigFractureTransCalc
public:
explicit RigFractureTransCalc(RimEclipseCase* caseToApply, RimFracture* fracture);
void computeTransmissibility();
// Calculations based on fracture polygon and eclipse grid cells
void computeTransmissibilityFromPolygonWithInfiniteConductivityInFracture();
bool planeCellIntersectionPolygons(size_t cellindex, std::vector<std::vector<cvf::Vec3d> > & polygons, cvf::Vec3d & localX, cvf::Vec3d & localY, cvf::Vec3d & localZ);
// Functions needed for upscaling from StimPlan grid to Eclipse Grid, for transmissibility calculations on eclipse grid
// 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);
static double arithmeticAverage(std::vector<double> values);
double cDarcy();
// Calculations based on StimPlan grid
void calculateStimPlanCellsMatrixTransmissibility(RigStimPlanCell* stimPlanCell, RigFractureStimPlanCellData* fracStimPlanCellData);
static void computeStimPlanCellTransmissibilityInFracture(RigStimPlanCell* stimPlanCell);
double computeRadialTransmissibilityToWellinStimPlanCell(RigStimPlanCell* stimPlanCell);
double computeLinearTransmissibilityToWellinStimPlanCell(RigStimPlanCell* stimPlanCell, double perforationLengthVertical, double perforationLengthHorizontal);
static void computeStimPlanCellTransmissibilityInFracture(const RigStimPlanCell& stimPlanCell);
double computeRadialTransmissibilityToWellinStimPlanCell(const RigStimPlanCell& stimPlanCell);
double computeLinearTransmissibilityToWellinStimPlanCell(const RigStimPlanCell& 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);
@@ -77,6 +75,7 @@ private:
RimFracture* m_fracture;
RimDefines::UnitSystem m_unitForCalculation;
double calculateMatrixTransmissibility(double permX, double NTG, double Ay, double dx, double skinfactor, double fractureAreaWeightedlength);
double calculateMatrixTransmissibility(double permX, double NTG, double Ay, double dx, double skinfactor, double fractureAreaWeightedlength);
double cDarcy();
};

10
ApplicationCode/ReservoirDataModel/RigStimPlanCell.cpp
View File

@@ -56,17 +56,19 @@ void RigStimPlanCell::setTransmissibilityInFracture(double valueHorizontal, doub
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigStimPlanCell::cellSizeX()
double RigStimPlanCell::cellSizeX() const
{
//The polygon corners are always stored in the same order
return (m_polygon[1] - m_polygon[0]).length();
if (m_polygon.size()>1) return (m_polygon[1] - m_polygon[0]).length();
return cvf::UNDEFINED_DOUBLE;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigStimPlanCell::cellSizeZ()
double RigStimPlanCell::cellSizeZ() const
{
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;
}

6
ApplicationCode/ReservoirDataModel/RigStimPlanCell.h
View File

@@ -38,7 +38,7 @@ public:
virtual ~RigStimPlanCell();
std::vector<cvf::Vec3d> getPolygon() { return m_polygon; }
double getConductivtyValue() { return m_concutivityValue; }
double getConductivtyValue() const { return m_concutivityValue; }
double getDisplayValue() { return m_displayValue; }
size_t getI() { return m_i; }
size_t getJ() { return m_j; }
@@ -50,8 +50,8 @@ public:
void setDisplayValue(double value) { m_displayValue = value; };
void setTransmissibilityInFracture(double valueHorizontal, double valueVertical);
double cellSizeX();
double cellSizeZ();
double cellSizeX() const;
double cellSizeZ() const;
private:
std::vector<cvf::Vec3d> m_polygon;
double m_displayValue;