OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-09 23:16:00 -06:00
Code Issues Packages Projects Releases Wiki Activity

#1585 Major renaming of fracture related methods and members

Browse Source
This commit is contained in:
Jacob Støren 2017-06-09 17:21:59 +02:00
parent 96981d1ab4
commit dceae0581e
18 changed files with 151 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
ApplicationCode/Commands/CompletionCommands/RicExportFractureCompletionsImpl.cpp
View File

@ -57,11 +57,11 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
for (RimFracture* fracture : fracturesAlongWellPath)
{
bool fractureFiniteCond = (fracture->attachedFractureDefinition()->fractureConductivity() == RimFractureTemplate::FINITE_CONDUCTIVITY);
bool fractureFiniteCond = (fracture->fractureTemplate()->conductivityType() == RimFractureTemplate::FINITE_CONDUCTIVITY);
using CellIdxSpace = RigTransmissibilityCondenser::CellAddress;
RimFractureTemplate* fracTemplate = fracture->attachedFractureDefinition();
RimFractureTemplate* fracTemplate = fracture->fractureTemplate();
const RigFractureGrid* fractureGrid = fracTemplate->fractureGrid();
RigTransmissibilityCondenser transCondenser;
@ -77,7 +77,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
RigEclipseToStimPlanCellTransmissibilityCalculator eclToFractureTransCalc(caseToApply,
fracture->transformMatrix(),
fracture->attachedFractureDefinition()->skinFactor,
fracture->fractureTemplate()->skinFactor,
cDarcyInCorrectUnit,
fractureCell);
@ -168,10 +168,10 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
{
////
//If fracture has orientation Azimuth or Transverse, assume only radial inflow
if (fracture->attachedFractureDefinition()->orientation() == RimFractureTemplate::AZIMUTH
|| fracture->attachedFractureDefinition()->orientation() == RimFractureTemplate::TRANSVERSE_WELL_PATH)
if (fracture->fractureTemplate()->orientationType() == RimFractureTemplate::AZIMUTH
|| fracture->fractureTemplate()->orientationType() == RimFractureTemplate::TRANSVERSE_WELL_PATH)
{
const RigFractureGrid* fracGrid = fracture->attachedFractureDefinition()->fractureGrid();
const RigFractureGrid* fracGrid = fracture->fractureTemplate()->fractureGrid();
std::pair<size_t, size_t> wellCellIJ = fracGrid->fractureCellAtWellCenter();
size_t wellCellIndex = fracGrid->getGlobalIndexFromIJ(wellCellIJ.first, wellCellIJ.second);
const RigFractureCell wellCell = fractureGrid->cellFromIndex(wellCellIndex);
@ -191,7 +191,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
////
//If fracture has orientation along well, linear inflow along well and radial flow at endpoints
else if (fracture->attachedFractureDefinition()->orientation() == RimFractureTemplate::ALONG_WELL_PATH)
else if (fracture->fractureTemplate()->orientationType() == RimFractureTemplate::ALONG_WELL_PATH)
{
RigWellPathStimplanIntersector wellFractureIntersector(wellPath->wellPathGeometry(), fracture);
const std::map<size_t, RigWellPathStimplanIntersector::WellCellIntersection >& fractureWellCells = wellFractureIntersector.intersections();
@ -251,7 +251,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
mainGrid->ijkFromCellIndex(externalCell.m_globalCellIdx, &i, &j, &k);
RigCompletionData compDat(wellPath->name(), {i,j,k} );
compDat.setFromFracture(trans, fracture->attachedFractureDefinition()->skinFactor());
compDat.setFromFracture(trans, fracture->fractureTemplate()->skinFactor());
compDat.addMetadata(fracture->name(), QString::number(trans));
fractureCompletions.push_back(compDat);
}

30
ApplicationCode/FileInterface/RifFractureExportTools.cpp
View File

@ -147,7 +147,7 @@ bool RifFractureExportTools::exportFracturesToEclipseDataInputFile(const QString
std::vector<RigFracturedEclipseCellExportData> fracDataVector = exportDataPrFracture[fracture];
double skinFactor = cvf::UNDEFINED_DOUBLE;
if (fracture->attachedFractureDefinition()) skinFactor = fracture->attachedFractureDefinition()->skinFactor();
if (fracture->fractureTemplate()) skinFactor = fracture->fractureTemplate()->skinFactor();
QString fractureName = fracture->name();
for (RigFracturedEclipseCellExportData fracData : fracDataVector)
@ -277,9 +277,9 @@ void RifFractureExportTools::printStimPlanCellsMatrixTransContributions(const st
for (RimFracture* fracture : fractures)
{
RimStimPlanFractureTemplate* fracTemplateStimPlan;
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracture->attachedFractureDefinition()))
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracture->fractureTemplate()))
{
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(fracture->attachedFractureDefinition());
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(fracture->fractureTemplate());
}
else continue;
@ -296,7 +296,7 @@ void RifFractureExportTools::printStimPlanCellsMatrixTransContributions(const st
RigEclipseToStimPlanCellTransmissibilityCalculator eclToStimPlanTransCalc(caseToApply,
fracture->transformMatrix(),
fracture->attachedFractureDefinition()->skinFactor,
fracture->fractureTemplate()->skinFactor,
cDarcyInCorrectUnit,
stimPlanCell);
@ -369,9 +369,9 @@ void RifFractureExportTools::printStimPlanFractureTrans(const std::vector<RimFra
RimFracture* fracture = fractures[0];
RimStimPlanFractureTemplate* fracTemplateStimPlan;
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracture->attachedFractureDefinition()))
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracture->fractureTemplate()))
{
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(fracture->attachedFractureDefinition());
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(fracture->fractureTemplate());
}
else return;
@ -578,15 +578,15 @@ void RifFractureExportTools::printTransmissibilityFractureToWell(const std::vect
out << fracture->name().left(15) + " ";
if (fracture->attachedFractureDefinition()->orientation == RimFractureTemplate::ALONG_WELL_PATH)
if (fracture->fractureTemplate()->orientationType == RimFractureTemplate::ALONG_WELL_PATH)
{
out << "Linear inflow";
out << qSetFieldWidth(5);
RimStimPlanFractureTemplate* fracTemplateStimPlan;
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracture->attachedFractureDefinition()))
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracture->fractureTemplate()))
{
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(fracture->attachedFractureDefinition());
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(fracture->fractureTemplate());
}
else continue;
@ -618,7 +618,7 @@ void RifFractureExportTools::printTransmissibilityFractureToWell(const std::vect
perforationLengthVert,
perforationLengthHor,
fracture->perforationEfficiency,
fracture->attachedFractureDefinition()->skinFactor(),
fracture->fractureTemplate()->skinFactor(),
caseToApply->eclipseCaseData()->darchysValue());
out << qSetFieldWidth(10);
@ -627,15 +627,15 @@ void RifFractureExportTools::printTransmissibilityFractureToWell(const std::vect
}
if (fracture->attachedFractureDefinition()->orientation == RimFractureTemplate::TRANSVERSE_WELL_PATH
|| fracture->attachedFractureDefinition()->orientation == RimFractureTemplate::AZIMUTH)
if (fracture->fractureTemplate()->orientationType == RimFractureTemplate::TRANSVERSE_WELL_PATH
|| fracture->fractureTemplate()->orientationType == RimFractureTemplate::AZIMUTH)
{
out << "Radial inflow";
RimStimPlanFractureTemplate* fracTemplateStimPlan;
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracture->attachedFractureDefinition()))
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracture->fractureTemplate()))
{
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(fracture->attachedFractureDefinition());
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(fracture->fractureTemplate());
}
else continue;
@ -650,7 +650,7 @@ void RifFractureExportTools::printTransmissibilityFractureToWell(const std::vect
stimPlanCell.cellSizeX(),
stimPlanCell.cellSizeZ(),
fracture->wellRadius(),
fracture->attachedFractureDefinition()->skinFactor(),
fracture->fractureTemplate()->skinFactor(),
caseToApply->eclipseCaseData()->darchysValue());
out << qSetFieldWidth(10);

18
ApplicationCode/ModelVisualization/RivWellFracturePartMgr.cpp
View File

@ -145,7 +145,7 @@ void RivWellFracturePartMgr::updatePartGeometryTexture(caf::DisplayCoordTransfor
}
}
RimFractureTemplate* fracTemplate = m_rimFracture->attachedFractureDefinition();
RimFractureTemplate* fracTemplate = m_rimFracture->fractureTemplate();
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(fracTemplate);
if (!stimPlanFracTemplate)
{
@ -270,9 +270,9 @@ void RivWellFracturePartMgr::generateStimPlanMeshPart(caf::DisplayCoordTransform
{
m_stimPlanMeshPart = nullptr;
if (!m_rimFracture->attachedFractureDefinition()) return;
if (!m_rimFracture->fractureTemplate()) return;
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->attachedFractureDefinition());
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate());
if (!stimPlanFracTemplate) return;
cvf::ref<cvf::DrawableGeo> stimPlanMeshGeo = createStimPlanMeshDrawable(stimPlanFracTemplate, displayCoordTransform);
@ -344,7 +344,7 @@ cvf::ref<cvf::DrawableGeo> RivWellFracturePartMgr::createStimPlanMeshDrawable(Ri
//--------------------------------------------------------------------------------------------------
void RivWellFracturePartMgr::getPolygonBB(float &polygonXmin, float &polygonXmax, float &polygonYmin, float &polygonYmax)
{
std::vector<cvf::Vec3f> polygon = m_rimFracture->attachedFractureDefinition()->fracturePolygon(m_rimFracture->fractureUnit());
std::vector<cvf::Vec3f> polygon = m_rimFracture->fractureTemplate()->fractureBorderPolygon(m_rimFracture->fractureUnit());
if (polygon.size() > 1)
{
@ -372,7 +372,7 @@ cvf::ref<cvf::DrawableGeo> RivWellFracturePartMgr::createPolygonDrawable(caf::Di
std::vector<cvf::Vec3f> vertices;
{
std::vector<cvf::Vec3f> polygon = m_rimFracture->attachedFractureDefinition()->fracturePolygon(m_rimFracture->fractureUnit());
std::vector<cvf::Vec3f> polygon = m_rimFracture->fractureTemplate()->fractureBorderPolygon(m_rimFracture->fractureUnit());
cvf::Mat4f m = m_rimFracture->transformMatrix();
std::vector<cvf::Vec3f> polygonDisplayCoords = transfromToFractureDisplayCoords(polygon, m, displayCoordTransform);
@ -450,13 +450,13 @@ void RivWellFracturePartMgr::appendGeometryPartsToModel(cvf::ModelBasicList* mod
if (m_part.isNull())
{
if (m_rimFracture->attachedFractureDefinition())
if (m_rimFracture->fractureTemplate())
{
if (dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->attachedFractureDefinition()))
if (dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate()))
{
updatePartGeometryTexture(displayCoordTransform);
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->attachedFractureDefinition());
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate());
if (stimPlanFracTemplate->showStimPlanMesh() && m_stimPlanMeshPart.notNull())
{
model->addPart(m_stimPlanMeshPart.p());
@ -474,7 +474,7 @@ void RivWellFracturePartMgr::appendGeometryPartsToModel(cvf::ModelBasicList* mod
model->addPart(m_part.p());
}
if (dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->attachedFractureDefinition())
if (dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate())
&& m_rimFracture->showPolygonFractureOutline()
&& m_polygonPart.notNull())
{

26
ApplicationCode/ProjectDataModel/Completions/RimEllipseFractureTemplate.cpp
View File

@ -86,7 +86,7 @@ void RimEllipseFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* cha
for (RimFracture* fracture : fractures)
{
if (fracture->attachedFractureDefinition() == this)
if (fracture->fractureTemplate() == this)
{
fracture->setRecomputeGeometryFlag();
}
@ -105,26 +105,28 @@ void RimEllipseFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* cha
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimUnitSystem::UnitSystem fractureUnit)
void RimEllipseFractureTemplate::fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* triangleIndices,
RimUnitSystem::UnitSystem neededUnit)
{
RigEllipsisTesselator tesselator(20);
float a = cvf::UNDEFINED_FLOAT;
float b = cvf::UNDEFINED_FLOAT;
if (fractureUnit == fractureTemplateUnit())
if (neededUnit == fractureTemplateUnit())
{
a = halfLength;
b = height / 2.0f;
}
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_METRIC && fractureUnit == RimUnitSystem::UNITS_FIELD)
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_METRIC && neededUnit == RimUnitSystem::UNITS_FIELD)
{
RiaLogging::info(QString("Converting fracture template geometry from metric to field"));
a = RimUnitSystem::meterToFeet(halfLength);
b = RimUnitSystem::meterToFeet(height / 2.0f);
}
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_FIELD && fractureUnit == RimUnitSystem::UNITS_METRIC)
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_FIELD && neededUnit == RimUnitSystem::UNITS_METRIC)
{
RiaLogging::info(QString("Converting fracture template geometry from field to metric"));
a = RimUnitSystem::feetToMeter(halfLength);
@ -144,14 +146,14 @@ void RimEllipseFractureTemplate::fractureGeometry(std::vector<cvf::Vec3f>* nodeC
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<cvf::Vec3f> RimEllipseFractureTemplate::fracturePolygon(RimUnitSystem::UnitSystem fractureUnit)
std::vector<cvf::Vec3f> RimEllipseFractureTemplate::fractureBorderPolygon(RimUnitSystem::UnitSystem neededUnit)
{
std::vector<cvf::Vec3f> polygon;
std::vector<cvf::Vec3f> nodeCoords;
std::vector<cvf::uint> triangleIndices;
fractureGeometry(&nodeCoords, &triangleIndices, fractureUnit);
fractureTriangleGeometry(&nodeCoords, &triangleIndices, neededUnit);
for (size_t i = 1; i < nodeCoords.size(); i++)
{
@ -236,7 +238,7 @@ void RimEllipseFractureTemplate::setupFractureGridCells()
cond = permeability * RimUnitSystem::inchToFeet(width);
}
std::vector<cvf::Vec3f> ellipseFracPolygon = fracturePolygon(fractureTemplateUnit());
std::vector<cvf::Vec3f> ellipseFracPolygon = fractureBorderPolygon(fractureTemplateUnit());
std::vector<cvf::Vec3d> ellipseFracPolygonDouble;
for (auto v : ellipseFracPolygon) ellipseFracPolygonDouble.push_back(static_cast<cvf::Vec3d>(v));
std::vector<std::vector<cvf::Vec3d> >clippedFracturePolygons = RigCellGeometryTools::intersectPolygons(cellPolygon, ellipseFracPolygonDouble);
@ -316,15 +318,15 @@ void RimEllipseFractureTemplate::defineUiOrdering(QString uiConfigName, caf::Pdm
caf::PdmUiGroup* geometryGroup = uiOrdering.addNewGroup("Geometry");
geometryGroup->add(&halfLength);
geometryGroup->add(&height);
geometryGroup->add(&orientation);
geometryGroup->add(&orientationType);
geometryGroup->add(&azimuthAngle);
caf::PdmUiGroup* trGr = uiOrdering.addNewGroup("Fracture Truncation");
m_fractureContainmentField()->defineUiOrdering(uiConfigName, *trGr);
m_fractureContainment()->defineUiOrdering(uiConfigName, *trGr);
caf::PdmUiGroup* propertyGroup = uiOrdering.addNewGroup("Properties");
propertyGroup->add(&fractureConductivity);
if (fractureConductivity == RimFractureTemplate::FINITE_CONDUCTIVITY)
propertyGroup->add(&conductivityType);
if (conductivityType == RimFractureTemplate::FINITE_CONDUCTIVITY)
{
propertyGroup->add(&permeability);
propertyGroup->add(&width);

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

@ -54,8 +54,10 @@ public:
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
void fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* polygonIndices, RimUnitSystem::UnitSystem fractureTemplateUnit);
std::vector<cvf::Vec3f> fracturePolygon(RimUnitSystem::UnitSystem fractureTemplateUnit);
void fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* polygonIndices,
RimUnitSystem::UnitSystem neededUnit);
std::vector<cvf::Vec3f> fractureBorderPolygon(RimUnitSystem::UnitSystem neededUnit);
void changeUnits();
const RigFractureGrid* fractureGrid() const;

70
ApplicationCode/ProjectDataModel/Completions/RimFracture.cpp
View File

@ -94,23 +94,23 @@ RimFracture::RimFracture(void)
CAF_PDM_InitField(&stimPlanTimeIndexToPlot, "timeIndexToPlot", 0, "StimPlan Time Step", "", "", "");
CAF_PDM_InitField(&m_i, "I", 1, "Fracture location cell I", "", "", "");
m_i.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&m_anchorPosEclipseCellI, "I", 1, "Fracture location cell I", "", "", "");
m_anchorPosEclipseCellI.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&m_j, "J", 1, "Fracture location cell J", "", "", "");
m_j.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&m_anchorPosEclipseCellJ, "J", 1, "Fracture location cell J", "", "", "");
m_anchorPosEclipseCellJ.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&m_k, "K", 1, "Fracture location cell K", "", "", "");
m_k.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&m_anchorPosEclipseCellK, "K", 1, "Fracture location cell K", "", "", "");
m_anchorPosEclipseCellK.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_displayIJK, "Cell_IJK", "Cell IJK", "", "", "");
m_displayIJK.registerGetMethod(this, &RimFracture::createOneBasedIJK);
m_displayIJK.registerGetMethod(this, &RimFracture::createOneBasedIJKText);
m_displayIJK.uiCapability()->setUiReadOnly(true);
m_rigFracture = new RigFracture;
m_recomputeGeometry = true;
m_rivFracture = new RivWellFracturePartMgr(this);
m_fracturePartMgr = new RivWellFracturePartMgr(this);
}
//--------------------------------------------------------------------------------------------------
@ -182,11 +182,11 @@ void RimFracture::fieldChangedByUi(const caf::PdmFieldHandle* changedField, cons
{
//perforationLength = m_fractureTemplate->perforationLength();
//TODO: Find out if performationLength should be in RimFractureTemplate or in RimEllipseFracTemplate
if (attachedFractureDefinition()) azimuth = m_fractureTemplate->azimuthAngle();
if (fractureTemplate()) azimuth = m_fractureTemplate->azimuthAngle();
else azimuth = 0.0;
updateAzimuthFromFractureDefinition();
updateAzimuthFromFractureTemplate();
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(attachedFractureDefinition());
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(fractureTemplate());
if (stimPlanFracTemplate)
{
stimPlanTimeIndexToPlot = stimPlanFracTemplate->activeTimeStepIndex;
@ -256,10 +256,10 @@ void RimFracture::computeGeometry()
std::vector<cvf::Vec3f> nodeCoords;
std::vector<cvf::uint> triangleIndices;
RimFractureTemplate* fractureDef = attachedFractureDefinition();
RimFractureTemplate* fractureDef = fractureTemplate();
if (fractureDef )
{
fractureDef->fractureGeometry(&nodeCoords, &triangleIndices, fractureUnit());
fractureDef->fractureTriangleGeometry(&nodeCoords, &triangleIndices, fractureUnit());
}
cvf::Mat4f m = transformMatrix();
@ -331,7 +331,7 @@ void RimFracture::setRecomputeGeometryFlag()
{
m_recomputeGeometry = true;
m_rivFracture->clearGeometryCache();
m_fracturePartMgr->clearGeometryCache();
}
//--------------------------------------------------------------------------------------------------
@ -357,9 +357,9 @@ cvf::Vec3d RimFracture::fracturePositionForUi() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimFracture::createOneBasedIJK() const
QString RimFracture::createOneBasedIJKText() const
{
return QString("Cell : [%1, %2, %3]").arg(m_i + 1).arg(m_j + 1).arg(m_k + 1);
return QString("Cell : [%1, %2, %3]").arg(m_anchorPosEclipseCellI + 1).arg(m_anchorPosEclipseCellJ + 1).arg(m_anchorPosEclipseCellK + 1);
}
//--------------------------------------------------------------------------------------------------
@ -387,9 +387,9 @@ QList<caf::PdmOptionItemInfo> RimFracture::calculateValueOptions(const caf::PdmF
}
else if (fieldNeedingOptions == &stimPlanTimeIndexToPlot)
{
if (attachedFractureDefinition())
if (fractureTemplate())
{
RimFractureTemplate* fracTemplate = attachedFractureDefinition();
RimFractureTemplate* fracTemplate = fractureTemplate();
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracTemplate))
{
RimStimPlanFractureTemplate* fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(fracTemplate);
@ -424,19 +424,19 @@ void RimFracture::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiO
perforationLength.uiCapability()->setUiName("Perforation Length [Ft]");
}
if (attachedFractureDefinition())
if (fractureTemplate())
{
if (attachedFractureDefinition()->orientation == RimFractureTemplate::ALONG_WELL_PATH
|| attachedFractureDefinition()->orientation == RimFractureTemplate::TRANSVERSE_WELL_PATH)
if (fractureTemplate()->orientationType == RimFractureTemplate::ALONG_WELL_PATH
|| fractureTemplate()->orientationType == RimFractureTemplate::TRANSVERSE_WELL_PATH)
{
azimuth.uiCapability()->setUiReadOnly(true);
}
else if (attachedFractureDefinition()->orientation == RimFractureTemplate::AZIMUTH)
else if (fractureTemplate()->orientationType == RimFractureTemplate::AZIMUTH)
{
azimuth.uiCapability()->setUiReadOnly(false);
}
if (attachedFractureDefinition()->orientation == RimFractureTemplate::ALONG_WELL_PATH)
if (fractureTemplate()->orientationType == RimFractureTemplate::ALONG_WELL_PATH)
{
perforationEfficiency.uiCapability()->setUiHidden(false);
perforationLength.uiCapability()->setUiHidden(false);
@ -447,7 +447,7 @@ void RimFracture::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiO
perforationLength.uiCapability()->setUiHidden(true);
}
RimFractureTemplate* fracTemplate = attachedFractureDefinition();
RimFractureTemplate* fracTemplate = fractureTemplate();
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracTemplate))
{
stimPlanTimeIndexToPlot.uiCapability()->setUiHidden(false);
@ -516,10 +516,10 @@ void RimFracture::setAnchorPosition(const cvf::Vec3d& pos)
const RigMainGrid* mainGrid = activeRiv->mainGrid();
if (!mainGrid) return;
cvf::BoundingBox polygonBBox;
polygonBBox.add(m_anchorPosition);
cvf::BoundingBox pointBBox;
pointBBox.add(m_anchorPosition);
mainGrid->findIntersectingCells(polygonBBox, &cellindecies);
mainGrid->findIntersectingCells(pointBBox, &cellindecies);
if (cellindecies.size() > 0)
{
@ -531,9 +531,9 @@ void RimFracture::setAnchorPosition(const cvf::Vec3d& pos)
if (mainGrid->ijkFromCellIndex(gridCellIndex, &i, &j, &k))
{
m_i = static_cast<int>(i);
m_j = static_cast<int>(j);
m_k = static_cast<int>(k);
m_anchorPosEclipseCellI = static_cast<int>(i);
m_anchorPosEclipseCellJ = static_cast<int>(j);
m_anchorPosEclipseCellK = static_cast<int>(k);
}
}
}
@ -556,19 +556,19 @@ void RimFracture::setFractureTemplate(RimFractureTemplate* fractureTemplate)
{
m_fractureTemplate = fractureTemplate;
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(attachedFractureDefinition());
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(fractureTemplate);
if (stimPlanFracTemplate)
{
stimPlanTimeIndexToPlot = stimPlanFracTemplate->activeTimeStepIndex;
}
this->updateAzimuthFromFractureDefinition();
this->updateAzimuthFromFractureTemplate();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimFractureTemplate* RimFracture::attachedFractureDefinition() const
RimFractureTemplate* RimFracture::fractureTemplate() const
{
return m_fractureTemplate();
}
@ -578,9 +578,9 @@ RimFractureTemplate* RimFracture::attachedFractureDefinition() const
//--------------------------------------------------------------------------------------------------
RivWellFracturePartMgr* RimFracture::fracturePartManager()
{
CVF_ASSERT(m_rivFracture.notNull());
CVF_ASSERT(m_fracturePartMgr.notNull());
return m_rivFracture.p();
return m_fracturePartMgr.p();
}

14
ApplicationCode/ProjectDataModel/Completions/RimFracture.h
View File

@ -77,7 +77,7 @@ public:
const RigFracture* attachedRigFracture() const;
void setFractureTemplate(RimFractureTemplate* fractureTemplate);
RimFractureTemplate* attachedFractureDefinition() const;
RimFractureTemplate* fractureTemplate() const;
RivWellFracturePartMgr* fracturePartManager();
@ -93,7 +93,7 @@ public:
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
cvf::Vec3d fracturePosition() const;
virtual void updateAzimuthFromFractureDefinition() = 0;
virtual void updateAzimuthFromFractureTemplate() = 0;
virtual double wellAzimuthAtFracturePosition() = 0;
protected:
@ -105,7 +105,7 @@ private:
bool isRecomputeGeometryFlagSet();
cvf::Vec3d fracturePositionForUi() const;
QString createOneBasedIJK() const;
QString createOneBasedIJKText() const;
virtual cvf::BoundingBox boundingBoxInDomainCoords() override;
@ -119,9 +119,9 @@ private:
cvf::ref<RigFracture> m_rigFracture;
bool m_recomputeGeometry;
caf::PdmField<int> m_i; // Zero based indexing
caf::PdmField<int> m_j; // Zero based indexing
caf::PdmField<int> m_k; // Zero based indexing
caf::PdmField<int> m_anchorPosEclipseCellI; // Zero based indexing
caf::PdmField<int> m_anchorPosEclipseCellJ; // Zero based indexing
caf::PdmField<int> m_anchorPosEclipseCellK; // Zero based indexing
cvf::ref<RivWellFracturePartMgr> m_rivFracture;
cvf::ref<RivWellFracturePartMgr> m_fracturePartMgr;
};

32
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplate.cpp
View File

@ -69,7 +69,7 @@ RimFractureTemplate::RimFractureTemplate(void)
CAF_PDM_InitField(&fractureTemplateUnit, "fractureTemplateUnit", caf::AppEnum<RimUnitSystem::UnitSystem>(RimUnitSystem::UNITS_METRIC), "Units System", "", "", "");
fractureTemplateUnit.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitField(&orientation, "Orientation", caf::AppEnum<FracOrientationEnum>(TRANSVERSE_WELL_PATH), "Fracture Orientation", "", "", "");
CAF_PDM_InitField(&orientationType, "Orientation", caf::AppEnum<FracOrientationEnum>(TRANSVERSE_WELL_PATH), "Fracture Orientation", "", "", "");
CAF_PDM_InitField(&azimuthAngle, "AzimuthAngle", 0.0f, "Azimuth Angle", "", "", ""); //Is this correct description?
CAF_PDM_InitField(&skinFactor, "SkinFactor", 1.0f, "Skin Factor", "", "", "");
@ -78,12 +78,12 @@ RimFractureTemplate::RimFractureTemplate(void)
perforationEfficiency.uiCapability()->setUiEditorTypeName(caf::PdmUiDoubleSliderEditor::uiEditorTypeName());
CAF_PDM_InitField(&wellDiameter, "wellDiameter", 0.216, "Well Diameter at Fracture", "", "", "");
CAF_PDM_InitField(&fractureConductivity, "FractureCondictivity", caf::AppEnum<FracConductivityEnum>(FINITE_CONDUCTIVITY), "Conductivity in Fracture", "", "", "");
CAF_PDM_InitField(&conductivityType, "FractureCondictivity", caf::AppEnum<FracConductivityEnum>(FINITE_CONDUCTIVITY), "Conductivity in Fracture", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_fractureContainmentField, "fractureContainmentField", "Fracture Containment", "", "", "");
m_fractureContainmentField = new RimFractureContainment();
m_fractureContainmentField.uiCapability()->setUiTreeHidden(true);
m_fractureContainmentField.uiCapability()->setUiTreeChildrenHidden(true);
CAF_PDM_InitFieldNoDefault(&m_fractureContainment, "fractureContainmentField", "Fracture Containment", "", "", "");
m_fractureContainment = new RimFractureContainment();
m_fractureContainment.uiCapability()->setUiTreeHidden(true);
m_fractureContainment.uiCapability()->setUiTreeChildrenHidden(true);
}
//--------------------------------------------------------------------------------------------------
@ -106,7 +106,7 @@ caf::PdmFieldHandle* RimFractureTemplate::userDescriptionField()
//--------------------------------------------------------------------------------------------------
void RimFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
if (changedField == &azimuthAngle || changedField == &orientation)
if (changedField == &azimuthAngle || changedField == &orientationType)
{
//Changes to one of these parameters should change all fractures with this fracture template attached.
RimProject* proj;
@ -119,17 +119,17 @@ void RimFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
for (RimFracture* fracture : fractures)
{
if (fracture->attachedFractureDefinition() == this)
if (fracture->fractureTemplate() == this)
{
if (changedField == &azimuthAngle && (abs(oldValue.toDouble() - fracture->azimuth()) < 1e-5))
{
fracture->updateAzimuthFromFractureDefinition();
fracture->updateAzimuthFromFractureTemplate();
fracture->setRecomputeGeometryFlag();
}
if (changedField == &orientation)
if (changedField == &orientationType)
{
fracture->updateAzimuthFromFractureDefinition();
fracture->updateAzimuthFromFractureTemplate();
fracture->setRecomputeGeometryFlag();
}
@ -150,7 +150,7 @@ void RimFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
for (RimFracture* fracture : fractures)
{
if (fracture->attachedFractureDefinition() == this)
if (fracture->fractureTemplate() == this)
{
if (changedField == &perforationLength && (abs(oldValue.toDouble() - fracture->perforationLength()) < 1e-5))
{
@ -186,17 +186,17 @@ void RimFractureTemplate::defineUiOrdering(QString uiConfigName, caf::PdmUiOrder
perforationLength.uiCapability()->setUiName("Perforation Length [Ft]");
}
if (orientation == RimFractureTemplate::ALONG_WELL_PATH
|| orientation == RimFractureTemplate::TRANSVERSE_WELL_PATH)
if (orientationType == RimFractureTemplate::ALONG_WELL_PATH
|| orientationType == RimFractureTemplate::TRANSVERSE_WELL_PATH)
{
azimuthAngle.uiCapability()->setUiHidden(true);
}
else if (orientation == RimFractureTemplate::AZIMUTH)
else if (orientationType == RimFractureTemplate::AZIMUTH)
{
azimuthAngle.uiCapability()->setUiHidden(false);
}
if (orientation == RimFractureTemplate::ALONG_WELL_PATH)
if (orientationType == RimFractureTemplate::ALONG_WELL_PATH)
{
perforationEfficiency.uiCapability()->setUiHidden(false);
perforationLength.uiCapability()->setUiHidden(false);

12
ApplicationCode/ProjectDataModel/Completions/RimFractureTemplate.h
View File

@ -62,26 +62,28 @@ public:
ALONG_WELL_PATH,
TRANSVERSE_WELL_PATH
};
caf::PdmField< caf::AppEnum< FracOrientationEnum > > orientation;
caf::PdmField< caf::AppEnum< FracOrientationEnum > > orientationType;
enum FracConductivityEnum
{
INFINITE_CONDUCTIVITY,
FINITE_CONDUCTIVITY,
};
caf::PdmField< caf::AppEnum< FracConductivityEnum > > fractureConductivity;
caf::PdmField< caf::AppEnum< FracConductivityEnum > > conductivityType;
caf::PdmField< RimUnitSystem::UnitSystemType > fractureTemplateUnit;
void setDefaultWellDiameterFromUnit();
virtual void fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimUnitSystem::UnitSystem fractureTemplateUnit) = 0;
virtual std::vector<cvf::Vec3f> fracturePolygon(RimUnitSystem::UnitSystem fractureTemplateUnit) = 0;
virtual void fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* triangleIndices,
RimUnitSystem::UnitSystem neededUnit) = 0;
virtual std::vector<cvf::Vec3f> fractureBorderPolygon(RimUnitSystem::UnitSystem neededUnit) = 0;
virtual const RigFractureGrid* fractureGrid() const = 0;
protected:
caf::PdmChildField<RimFractureContainment*> m_fractureContainmentField;
caf::PdmChildField<RimFractureContainment*> m_fractureContainment;
virtual caf::PdmFieldHandle* userDescriptionField() override;
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;

10
ApplicationCode/ProjectDataModel/Completions/RimSimWellFracture.cpp
View File

@ -73,10 +73,10 @@ void RimSimWellFracture::setClosestWellCoord(cvf::Vec3d& position, size_t branch
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellFracture::updateAzimuthFromFractureDefinition()
void RimSimWellFracture::updateAzimuthFromFractureTemplate()
{
RimFractureTemplate::FracOrientationEnum orientation;
if (attachedFractureDefinition()) orientation = attachedFractureDefinition()->orientation();
if (fractureTemplate()) orientation = fractureTemplate()->orientationType();
else orientation = RimFractureTemplate::AZIMUTH;
if (orientation == RimFractureTemplate::ALONG_WELL_PATH || orientation== RimFractureTemplate::TRANSVERSE_WELL_PATH)
@ -95,7 +95,7 @@ void RimSimWellFracture::updateAzimuthFromFractureDefinition()
}
else //Azimuth value read from template
{
if (attachedFractureDefinition()) azimuth = attachedFractureDefinition()->azimuthAngle;
if (fractureTemplate()) azimuth = fractureTemplate()->azimuthAngle;
else azimuth = 0.0;
}
}
@ -133,12 +133,12 @@ void RimSimWellFracture::fieldChangedByUi(const caf::PdmFieldHandle* changedFiel
updateFracturePositionFromLocation();
RimFractureTemplate::FracOrientationEnum orientation;
if (attachedFractureDefinition()) orientation = attachedFractureDefinition()->orientation();
if (fractureTemplate()) orientation = fractureTemplate()->orientationType();
else orientation = RimFractureTemplate::AZIMUTH;
if (orientation != RimFractureTemplate::AZIMUTH)
{
updateAzimuthFromFractureDefinition();
updateAzimuthFromFractureTemplate();
}
RimProject* proj;

2
ApplicationCode/ProjectDataModel/Completions/RimSimWellFracture.h
View File

@ -42,7 +42,7 @@ public:
void recomputeWellCenterlineCoordinates();
void updateFracturePositionFromLocation();
void updateAzimuthFromFractureDefinition() override;
void updateAzimuthFromFractureTemplate() override;
double wellAzimuthAtFracturePosition() override;
double wellDipAtFracturePosition();

22
ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.cpp
View File

@ -106,7 +106,7 @@ void RimStimPlanFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* ch
proj->descendantsIncludingThisOfType(fractures);
for (RimFracture* fracture : fractures)
{
if (fracture->attachedFractureDefinition() == this)
if (fracture->fractureTemplate() == this)
{
fracture->stimPlanTimeIndexToPlot = activeTimeStepIndex;
fracture->setRecomputeGeometryFlag();
@ -129,7 +129,7 @@ void RimStimPlanFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* ch
for (RimFracture* fracture : fractures)
{
if (fracture->attachedFractureDefinition() == this)
if (fracture->fractureTemplate() == this)
{
fracture->setRecomputeGeometryFlag();
}
@ -618,7 +618,9 @@ QString RimStimPlanFractureTemplate::getAttributeValueString(QXmlStreamReader &x
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimStimPlanFractureTemplate::fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimUnitSystem::UnitSystem fractureUnit)
void RimStimPlanFractureTemplate::fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* triangleIndices,
RimUnitSystem::UnitSystem neededUnit)
{
if (m_stimPlanFractureDefinitionData.isNull())
@ -632,18 +634,18 @@ void RimStimPlanFractureTemplate::fractureGeometry(std::vector<cvf::Vec3f>* node
std::vector<double> adjustedDepths = adjustedDepthCoordsAroundWellPathPosition();
if (fractureUnit == fractureTemplateUnit())
if (neededUnit == fractureTemplateUnit())
{
RiaLogging::debug(QString("No conversion necessary for %1").arg(name));
}
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_METRIC && fractureUnit == RimUnitSystem::UNITS_FIELD)
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_METRIC && neededUnit == RimUnitSystem::UNITS_FIELD)
{
RiaLogging::info(QString("Converting StimPlan geometry from metric to field for fracture template %1").arg(name));
for (double& value : adjustedDepths) value = RimUnitSystem::meterToFeet(value);
for (double& value : xCoords) value = RimUnitSystem::meterToFeet(value);
}
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_FIELD && fractureUnit == RimUnitSystem::UNITS_METRIC)
else if (fractureTemplateUnit() == RimUnitSystem::UNITS_FIELD && neededUnit == RimUnitSystem::UNITS_METRIC)
{
RiaLogging::info(QString("Converting StimPlan geometry from field to metric for fracture template %1").arg(name));
for (double& value : adjustedDepths) value = RimUnitSystem::feetToMeter(value);
@ -953,7 +955,7 @@ std::vector<cvf::Vec3d> RimStimPlanFractureTemplate::getStimPlanColPolygon(size_
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<cvf::Vec3f> RimStimPlanFractureTemplate::fracturePolygon(RimUnitSystem::UnitSystem fractureUnit)
std::vector<cvf::Vec3f> RimStimPlanFractureTemplate::fractureBorderPolygon(RimUnitSystem::UnitSystem fractureUnit)
{
std::vector<cvf::Vec3f> polygon;
@ -1090,14 +1092,14 @@ void RimStimPlanFractureTemplate::defineUiOrdering(QString uiConfigName, caf::Pd
fileGroup->add(&wellPathDepthAtFracture);
caf::PdmUiGroup* geometryGroup = uiOrdering.addNewGroup("Geometry");
geometryGroup->add(&orientation);
geometryGroup->add(&orientationType);
geometryGroup->add(&azimuthAngle);
caf::PdmUiGroup* trGr = uiOrdering.addNewGroup("Fracture Truncation");
m_fractureContainmentField()->defineUiOrdering(uiConfigName, *trGr);
m_fractureContainment()->defineUiOrdering(uiConfigName, *trGr);
caf::PdmUiGroup* propertyGroup = uiOrdering.addNewGroup("Properties");
propertyGroup->add(&fractureConductivity);
propertyGroup->add(&conductivityType);
propertyGroup->add(&skinFactor);
propertyGroup->add(&perforationLength);
propertyGroup->add(&perforationEfficiency);

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

@ -66,8 +66,10 @@ public:
const QString& fileName();
QString fileNameWithOutPath();
void fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimUnitSystem::UnitSystem fractureUnit) override;
std::vector<cvf::Vec3f> fracturePolygon(RimUnitSystem::UnitSystem fractureUnit);
void fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* triangleIndices,
RimUnitSystem::UnitSystem neededUnit) override;
std::vector<cvf::Vec3f> fractureBorderPolygon(RimUnitSystem::UnitSystem neededUnit);
void sortPolygon(std::vector<cvf::Vec3f> &polygon);
std::vector<double> getStimPlanTimeValues();

8
ApplicationCode/ProjectDataModel/Completions/RimWellPathFracture.cpp
View File

@ -76,7 +76,7 @@ void RimWellPathFracture::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
if (changedField == &m_measuredDepth)
{
updatePositionFromMeasuredDepth();
updateAzimuthFromFractureDefinition();
updateAzimuthFromFractureTemplate();
RimProject* proj = nullptr;
this->firstAncestorOrThisOfType(proj);
@ -87,10 +87,10 @@ void RimWellPathFracture::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPathFracture::updateAzimuthFromFractureDefinition()
void RimWellPathFracture::updateAzimuthFromFractureTemplate()
{
RimFractureTemplate::FracOrientationEnum orientation;
if (attachedFractureDefinition()) orientation = attachedFractureDefinition()->orientation();
if (fractureTemplate()) orientation = fractureTemplate()->orientationType();
else orientation = RimFractureTemplate::AZIMUTH;
if (orientation == RimFractureTemplate::ALONG_WELL_PATH || orientation == RimFractureTemplate::TRANSVERSE_WELL_PATH)
@ -111,7 +111,7 @@ void RimWellPathFracture::updateAzimuthFromFractureDefinition()
//TODO: Reset value if choosing azimuth in frac template!
// else //Azimuth value read from template
// {
// azimuth = attachedFractureDefinition()->azimuthAngle;
// azimuth = attachedFractureTemplate()->azimuthAngle;
// }
}

2
ApplicationCode/ProjectDataModel/Completions/RimWellPathFracture.h
View File

@ -41,7 +41,7 @@ public:
void setMeasuredDepth(double mdValue);
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
virtual void updateAzimuthFromFractureDefinition() override;
virtual void updateAzimuthFromFractureTemplate() override;
double wellAzimuthAtFracturePosition() override;

6
ApplicationCode/ReservoirDataModel/RigFractureTransCalc.cpp
View File

@ -85,7 +85,7 @@ RigFractureTransCalc::RigFractureTransCalc(RimEclipseCase* caseToApply, RimFract
//--------------------------------------------------------------------------------------------------
std::vector<RigFracturedEclipseCellExportData> RigFractureTransCalc::computeTransmissibilityFromPolygonWithInfiniteConductivityInFracture()
{
if (m_fracture->attachedFractureDefinition()->fractureConductivity == RimFractureTemplate::FINITE_CONDUCTIVITY)
if (m_fracture->fractureTemplate()->conductivityType == RimFractureTemplate::FINITE_CONDUCTIVITY)
{
RiaLogging::warning(QString("Transimssibility for finite conductity in fracture not yet implemented."));
RiaLogging::warning(QString("Performing calculation for infinite conductivity instead."));
@ -166,7 +166,7 @@ std::vector<RigFracturedEclipseCellExportData> RigFractureTransCalc::computeTra
RigFracturedEclipseCellExportData fracData;
fracData.reservoirCellIndex = fracCell;
std::vector<cvf::Vec3f> fracPolygon = m_fracture->attachedFractureDefinition()->fracturePolygon(m_unitForCalculation);
std::vector<cvf::Vec3f> fracPolygon = m_fracture->fractureTemplate()->fractureBorderPolygon(m_unitForCalculation);
std::vector<cvf::Vec3d> fracPolygonDouble;
for (auto v : fracPolygon) fracPolygonDouble.push_back(static_cast<cvf::Vec3d>(v));
@ -219,7 +219,7 @@ std::vector<RigFracturedEclipseCellExportData> RigFractureTransCalc::computeTra
for (double lengtXarea : lengthXareaOfFractureParts) totalAreaXLength += lengtXarea;
double fractureAreaWeightedlength = totalAreaXLength / fractureArea;
double skinfactor = m_fracture->attachedFractureDefinition()->skinFactor;
double skinfactor = m_fracture->fractureTemplate()->skinFactor;
double transmissibility_X = RigFractureTransmissibilityEquations::matrixToFractureTrans(permY, NTG, Ay, dx, skinfactor, fractureAreaWeightedlength, cDarchy);
double transmissibility_Y = RigFractureTransmissibilityEquations::matrixToFractureTrans(permX, NTG, Ax, dy, skinfactor, fractureAreaWeightedlength, cDarchy);

10
ApplicationCode/ReservoirDataModel/RigStimPlanUpscalingCalc.cpp
View File

@ -47,9 +47,9 @@ RigStimPlanUpscalingCalc::RigStimPlanUpscalingCalc(RimEclipseCase* caseToApply,
std::pair<double, double> RigStimPlanUpscalingCalc::flowAcrossLayersUpscaling(QString resultName, QString resultUnit, size_t timeStepIndex, RimUnitSystem::UnitSystem unitSystem, size_t eclipseCellIndex)
{
RimStimPlanFractureTemplate* fracTemplateStimPlan;
if (dynamic_cast<RimStimPlanFractureTemplate*>(m_fracture->attachedFractureDefinition()))
if (dynamic_cast<RimStimPlanFractureTemplate*>(m_fracture->fractureTemplate()))
{
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(m_fracture->attachedFractureDefinition());
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(m_fracture->fractureTemplate());
}
else return std::make_pair(cvf::UNDEFINED_DOUBLE, cvf::UNDEFINED_DOUBLE);
@ -84,7 +84,7 @@ std::pair<double, double> RigStimPlanUpscalingCalc::flowAcrossLayersUpscaling(QS
directionAcrossLayers = cvf::Vec3d(0.0, -1.0, 0.0);
directionAlongLayers = cvf::Vec3d(1.0, 0.0, 0.0);
std::vector<cvf::Vec3f> fracPolygon = m_fracture->attachedFractureDefinition()->fracturePolygon(unitSystem);
std::vector<cvf::Vec3f> fracPolygon = m_fracture->fractureTemplate()->fractureBorderPolygon(unitSystem);
std::vector<std::vector<cvf::Vec3d> > polygonsDescribingFractureInCell;
std::vector<double> upscaledConductivitiesHA;
@ -273,9 +273,9 @@ std::vector<RigFracturedEclipseCellExportData> RigStimPlanUpscalingCalc::comput
std::vector<RigFracturedEclipseCellExportData> fracDataVec;
RimStimPlanFractureTemplate* fracTemplateStimPlan;
if (dynamic_cast<RimStimPlanFractureTemplate*>(m_fracture->attachedFractureDefinition()))
if (dynamic_cast<RimStimPlanFractureTemplate*>(m_fracture->fractureTemplate()))
{
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(m_fracture->attachedFractureDefinition());
fracTemplateStimPlan = dynamic_cast<RimStimPlanFractureTemplate*>(m_fracture->fractureTemplate());
}
else
{

2
ApplicationCode/ReservoirDataModel/RigWellPathStimplanIntersector.cpp
View File

@ -22,7 +22,7 @@ RigWellPathStimplanIntersector::RigWellPathStimplanIntersector(const RigWellPath
std::vector<cvf::Vec3f> fracturePolygonf ;
std::vector<std::vector<cvf::Vec3d> > stpCellPolygons;
{
RimFractureTemplate* fractureTemplate = rimFracture->attachedFractureDefinition();
RimFractureTemplate* fractureTemplate = rimFracture->fractureTemplate();
{
const std::vector<RigFractureCell>& stpCells = fractureTemplate->fractureGrid()->fractureCells();