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

#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) for (RimFracture* fracture : fracturesAlongWellPath)
{ {
bool fractureFiniteCond = (fracture->attachedFractureDefinition()->fractureConductivity() == RimFractureTemplate::FINITE_CONDUCTIVITY); bool fractureFiniteCond = (fracture->fractureTemplate()->conductivityType() == RimFractureTemplate::FINITE_CONDUCTIVITY);
using CellIdxSpace = RigTransmissibilityCondenser::CellAddress; using CellIdxSpace = RigTransmissibilityCondenser::CellAddress;
RimFractureTemplate* fracTemplate = fracture->attachedFractureDefinition(); RimFractureTemplate* fracTemplate = fracture->fractureTemplate();
const RigFractureGrid* fractureGrid = fracTemplate->fractureGrid(); const RigFractureGrid* fractureGrid = fracTemplate->fractureGrid();
RigTransmissibilityCondenser transCondenser; RigTransmissibilityCondenser transCondenser;
@ -77,7 +77,7 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
RigEclipseToStimPlanCellTransmissibilityCalculator eclToFractureTransCalc(caseToApply, RigEclipseToStimPlanCellTransmissibilityCalculator eclToFractureTransCalc(caseToApply,
fracture->transformMatrix(), fracture->transformMatrix(),
fracture->attachedFractureDefinition()->skinFactor, fracture->fractureTemplate()->skinFactor,
cDarcyInCorrectUnit, cDarcyInCorrectUnit,
fractureCell); fractureCell);
@ -168,10 +168,10 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateFractur
{ {
//// ////
//If fracture has orientation Azimuth or Transverse, assume only radial inflow //If fracture has orientation Azimuth or Transverse, assume only radial inflow
if (fracture->attachedFractureDefinition()->orientation() == RimFractureTemplate::AZIMUTH if (fracture->fractureTemplate()->orientationType() == RimFractureTemplate::AZIMUTH
|| fracture->attachedFractureDefinition()->orientation() == RimFractureTemplate::TRANSVERSE_WELL_PATH) || 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(); std::pair<size_t, size_t> wellCellIJ = fracGrid->fractureCellAtWellCenter();
size_t wellCellIndex = fracGrid->getGlobalIndexFromIJ(wellCellIJ.first, wellCellIJ.second); size_t wellCellIndex = fracGrid->getGlobalIndexFromIJ(wellCellIJ.first, wellCellIJ.second);
const RigFractureCell wellCell = fractureGrid->cellFromIndex(wellCellIndex); 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 //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); RigWellPathStimplanIntersector wellFractureIntersector(wellPath->wellPathGeometry(), fracture);
const std::map<size_t, RigWellPathStimplanIntersector::WellCellIntersection >& fractureWellCells = wellFractureIntersector.intersections(); 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); mainGrid->ijkFromCellIndex(externalCell.m_globalCellIdx, &i, &j, &k);
RigCompletionData compDat(wellPath->name(), {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)); compDat.addMetadata(fracture->name(), QString::number(trans));
fractureCompletions.push_back(compDat); 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]; std::vector<RigFracturedEclipseCellExportData> fracDataVector = exportDataPrFracture[fracture];
double skinFactor = cvf::UNDEFINED_DOUBLE; double skinFactor = cvf::UNDEFINED_DOUBLE;
if (fracture->attachedFractureDefinition()) skinFactor = fracture->attachedFractureDefinition()->skinFactor(); if (fracture->fractureTemplate()) skinFactor = fracture->fractureTemplate()->skinFactor();
QString fractureName = fracture->name(); QString fractureName = fracture->name();
for (RigFracturedEclipseCellExportData fracData : fracDataVector) for (RigFracturedEclipseCellExportData fracData : fracDataVector)
@ -277,9 +277,9 @@ void RifFractureExportTools::printStimPlanCellsMatrixTransContributions(const st
for (RimFracture* fracture : fractures) for (RimFracture* fracture : fractures)
{ {
RimStimPlanFractureTemplate* fracTemplateStimPlan; 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; else continue;
@ -296,7 +296,7 @@ void RifFractureExportTools::printStimPlanCellsMatrixTransContributions(const st
RigEclipseToStimPlanCellTransmissibilityCalculator eclToStimPlanTransCalc(caseToApply, RigEclipseToStimPlanCellTransmissibilityCalculator eclToStimPlanTransCalc(caseToApply,
fracture->transformMatrix(), fracture->transformMatrix(),
fracture->attachedFractureDefinition()->skinFactor, fracture->fractureTemplate()->skinFactor,
cDarcyInCorrectUnit, cDarcyInCorrectUnit,
stimPlanCell); stimPlanCell);
@ -369,9 +369,9 @@ void RifFractureExportTools::printStimPlanFractureTrans(const std::vector<RimFra
RimFracture* fracture = fractures[0]; RimFracture* fracture = fractures[0];
RimStimPlanFractureTemplate* fracTemplateStimPlan; 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; else return;
@ -578,15 +578,15 @@ void RifFractureExportTools::printTransmissibilityFractureToWell(const std::vect
out << fracture->name().left(15) + " "; 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 << "Linear inflow";
out << qSetFieldWidth(5); out << qSetFieldWidth(5);
RimStimPlanFractureTemplate* fracTemplateStimPlan; 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; else continue;
@ -618,7 +618,7 @@ void RifFractureExportTools::printTransmissibilityFractureToWell(const std::vect
perforationLengthVert, perforationLengthVert,
perforationLengthHor, perforationLengthHor,
fracture->perforationEfficiency, fracture->perforationEfficiency,
fracture->attachedFractureDefinition()->skinFactor(), fracture->fractureTemplate()->skinFactor(),
caseToApply->eclipseCaseData()->darchysValue()); caseToApply->eclipseCaseData()->darchysValue());
out << qSetFieldWidth(10); out << qSetFieldWidth(10);
@ -627,15 +627,15 @@ void RifFractureExportTools::printTransmissibilityFractureToWell(const std::vect
} }
if (fracture->attachedFractureDefinition()->orientation == RimFractureTemplate::TRANSVERSE_WELL_PATH if (fracture->fractureTemplate()->orientationType == RimFractureTemplate::TRANSVERSE_WELL_PATH
|| fracture->attachedFractureDefinition()->orientation == RimFractureTemplate::AZIMUTH) || fracture->fractureTemplate()->orientationType == RimFractureTemplate::AZIMUTH)
{ {
out << "Radial inflow"; out << "Radial inflow";
RimStimPlanFractureTemplate* fracTemplateStimPlan; 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; else continue;
@ -650,7 +650,7 @@ void RifFractureExportTools::printTransmissibilityFractureToWell(const std::vect
stimPlanCell.cellSizeX(), stimPlanCell.cellSizeX(),
stimPlanCell.cellSizeZ(), stimPlanCell.cellSizeZ(),
fracture->wellRadius(), fracture->wellRadius(),
fracture->attachedFractureDefinition()->skinFactor(), fracture->fractureTemplate()->skinFactor(),
caseToApply->eclipseCaseData()->darchysValue()); caseToApply->eclipseCaseData()->darchysValue());
out << qSetFieldWidth(10); 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); RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(fracTemplate);
if (!stimPlanFracTemplate) if (!stimPlanFracTemplate)
{ {
@ -270,9 +270,9 @@ void RivWellFracturePartMgr::generateStimPlanMeshPart(caf::DisplayCoordTransform
{ {
m_stimPlanMeshPart = nullptr; 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; if (!stimPlanFracTemplate) return;
cvf::ref<cvf::DrawableGeo> stimPlanMeshGeo = createStimPlanMeshDrawable(stimPlanFracTemplate, displayCoordTransform); 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) 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) 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> 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(); cvf::Mat4f m = m_rimFracture->transformMatrix();
std::vector<cvf::Vec3f> polygonDisplayCoords = transfromToFractureDisplayCoords(polygon, m, displayCoordTransform); 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_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); updatePartGeometryTexture(displayCoordTransform);
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->attachedFractureDefinition()); RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate());
if (stimPlanFracTemplate->showStimPlanMesh() && m_stimPlanMeshPart.notNull()) if (stimPlanFracTemplate->showStimPlanMesh() && m_stimPlanMeshPart.notNull())
{ {
model->addPart(m_stimPlanMeshPart.p()); model->addPart(m_stimPlanMeshPart.p());
@ -474,7 +474,7 @@ void RivWellFracturePartMgr::appendGeometryPartsToModel(cvf::ModelBasicList* mod
model->addPart(m_part.p()); model->addPart(m_part.p());
} }
if (dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->attachedFractureDefinition()) if (dynamic_cast<RimStimPlanFractureTemplate*>(m_rimFracture->fractureTemplate())
&& m_rimFracture->showPolygonFractureOutline() && m_rimFracture->showPolygonFractureOutline()
&& m_polygonPart.notNull()) && 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) for (RimFracture* fracture : fractures)
{ {
if (fracture->attachedFractureDefinition() == this) if (fracture->fractureTemplate() == this)
{ {
fracture->setRecomputeGeometryFlag(); 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); RigEllipsisTesselator tesselator(20);
float a = cvf::UNDEFINED_FLOAT; float a = cvf::UNDEFINED_FLOAT;
float b = cvf::UNDEFINED_FLOAT; float b = cvf::UNDEFINED_FLOAT;
if (fractureUnit == fractureTemplateUnit()) if (neededUnit == fractureTemplateUnit())
{ {
a = halfLength; a = halfLength;
b = height / 2.0f; 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")); RiaLogging::info(QString("Converting fracture template geometry from metric to field"));
a = RimUnitSystem::meterToFeet(halfLength); a = RimUnitSystem::meterToFeet(halfLength);
b = RimUnitSystem::meterToFeet(height / 2.0f); 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")); RiaLogging::info(QString("Converting fracture template geometry from field to metric"));
a = RimUnitSystem::feetToMeter(halfLength); 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> polygon;
std::vector<cvf::Vec3f> nodeCoords; std::vector<cvf::Vec3f> nodeCoords;
std::vector<cvf::uint> triangleIndices; std::vector<cvf::uint> triangleIndices;
fractureGeometry(&nodeCoords, &triangleIndices, fractureUnit); fractureTriangleGeometry(&nodeCoords, &triangleIndices, neededUnit);
for (size_t i = 1; i < nodeCoords.size(); i++) for (size_t i = 1; i < nodeCoords.size(); i++)
{ {
@ -236,7 +238,7 @@ void RimEllipseFractureTemplate::setupFractureGridCells()
cond = permeability * RimUnitSystem::inchToFeet(width); cond = permeability * RimUnitSystem::inchToFeet(width);
} }
std::vector<cvf::Vec3f> ellipseFracPolygon = fracturePolygon(fractureTemplateUnit()); std::vector<cvf::Vec3f> ellipseFracPolygon = fractureBorderPolygon(fractureTemplateUnit());
std::vector<cvf::Vec3d> ellipseFracPolygonDouble; std::vector<cvf::Vec3d> ellipseFracPolygonDouble;
for (auto v : ellipseFracPolygon) ellipseFracPolygonDouble.push_back(static_cast<cvf::Vec3d>(v)); for (auto v : ellipseFracPolygon) ellipseFracPolygonDouble.push_back(static_cast<cvf::Vec3d>(v));
std::vector<std::vector<cvf::Vec3d> >clippedFracturePolygons = RigCellGeometryTools::intersectPolygons(cellPolygon, ellipseFracPolygonDouble); 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"); caf::PdmUiGroup* geometryGroup = uiOrdering.addNewGroup("Geometry");
geometryGroup->add(&halfLength); geometryGroup->add(&halfLength);
geometryGroup->add(&height); geometryGroup->add(&height);
geometryGroup->add(&orientation); geometryGroup->add(&orientationType);
geometryGroup->add(&azimuthAngle); geometryGroup->add(&azimuthAngle);
caf::PdmUiGroup* trGr = uiOrdering.addNewGroup("Fracture Truncation"); caf::PdmUiGroup* trGr = uiOrdering.addNewGroup("Fracture Truncation");
m_fractureContainmentField()->defineUiOrdering(uiConfigName, *trGr); m_fractureContainment()->defineUiOrdering(uiConfigName, *trGr);
caf::PdmUiGroup* propertyGroup = uiOrdering.addNewGroup("Properties"); caf::PdmUiGroup* propertyGroup = uiOrdering.addNewGroup("Properties");
propertyGroup->add(&fractureConductivity); propertyGroup->add(&conductivityType);
if (fractureConductivity == RimFractureTemplate::FINITE_CONDUCTIVITY) if (conductivityType == RimFractureTemplate::FINITE_CONDUCTIVITY)
{ {
propertyGroup->add(&permeability); propertyGroup->add(&permeability);
propertyGroup->add(&width); 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; 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); void fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::Vec3f> fracturePolygon(RimUnitSystem::UnitSystem fractureTemplateUnit); std::vector<cvf::uint>* polygonIndices,
RimUnitSystem::UnitSystem neededUnit);
std::vector<cvf::Vec3f> fractureBorderPolygon(RimUnitSystem::UnitSystem neededUnit);
void changeUnits(); void changeUnits();
const RigFractureGrid* fractureGrid() const; 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(&stimPlanTimeIndexToPlot, "timeIndexToPlot", 0, "StimPlan Time Step", "", "", "");
CAF_PDM_InitField(&m_i, "I", 1, "Fracture location cell I", "", "", ""); CAF_PDM_InitField(&m_anchorPosEclipseCellI, "I", 1, "Fracture location cell I", "", "", "");
m_i.uiCapability()->setUiHidden(true); m_anchorPosEclipseCellI.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&m_j, "J", 1, "Fracture location cell J", "", "", ""); CAF_PDM_InitField(&m_anchorPosEclipseCellJ, "J", 1, "Fracture location cell J", "", "", "");
m_j.uiCapability()->setUiHidden(true); m_anchorPosEclipseCellJ.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&m_k, "K", 1, "Fracture location cell K", "", "", ""); CAF_PDM_InitField(&m_anchorPosEclipseCellK, "K", 1, "Fracture location cell K", "", "", "");
m_k.uiCapability()->setUiHidden(true); m_anchorPosEclipseCellK.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_displayIJK, "Cell_IJK", "Cell IJK", "", "", ""); 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_displayIJK.uiCapability()->setUiReadOnly(true);
m_rigFracture = new RigFracture; m_rigFracture = new RigFracture;
m_recomputeGeometry = true; 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(); //perforationLength = m_fractureTemplate->perforationLength();
//TODO: Find out if performationLength should be in RimFractureTemplate or in RimEllipseFracTemplate //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; else azimuth = 0.0;
updateAzimuthFromFractureDefinition(); updateAzimuthFromFractureTemplate();
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(attachedFractureDefinition()); RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(fractureTemplate());
if (stimPlanFracTemplate) if (stimPlanFracTemplate)
{ {
stimPlanTimeIndexToPlot = stimPlanFracTemplate->activeTimeStepIndex; stimPlanTimeIndexToPlot = stimPlanFracTemplate->activeTimeStepIndex;
@ -256,10 +256,10 @@ void RimFracture::computeGeometry()
std::vector<cvf::Vec3f> nodeCoords; std::vector<cvf::Vec3f> nodeCoords;
std::vector<cvf::uint> triangleIndices; std::vector<cvf::uint> triangleIndices;
RimFractureTemplate* fractureDef = attachedFractureDefinition(); RimFractureTemplate* fractureDef = fractureTemplate();
if (fractureDef ) if (fractureDef )
{ {
fractureDef->fractureGeometry(&nodeCoords, &triangleIndices, fractureUnit()); fractureDef->fractureTriangleGeometry(&nodeCoords, &triangleIndices, fractureUnit());
} }
cvf::Mat4f m = transformMatrix(); cvf::Mat4f m = transformMatrix();
@ -331,7 +331,7 @@ void RimFracture::setRecomputeGeometryFlag()
{ {
m_recomputeGeometry = true; 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) else if (fieldNeedingOptions == &stimPlanTimeIndexToPlot)
{ {
if (attachedFractureDefinition()) if (fractureTemplate())
{ {
RimFractureTemplate* fracTemplate = attachedFractureDefinition(); RimFractureTemplate* fracTemplate = fractureTemplate();
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracTemplate)) if (dynamic_cast<RimStimPlanFractureTemplate*>(fracTemplate))
{ {
RimStimPlanFractureTemplate* fracTemplateStimPlan = 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]"); perforationLength.uiCapability()->setUiName("Perforation Length [Ft]");
} }
if (attachedFractureDefinition()) if (fractureTemplate())
{ {
if (attachedFractureDefinition()->orientation == RimFractureTemplate::ALONG_WELL_PATH if (fractureTemplate()->orientationType == RimFractureTemplate::ALONG_WELL_PATH
|| attachedFractureDefinition()->orientation == RimFractureTemplate::TRANSVERSE_WELL_PATH) || fractureTemplate()->orientationType == RimFractureTemplate::TRANSVERSE_WELL_PATH)
{ {
azimuth.uiCapability()->setUiReadOnly(true); azimuth.uiCapability()->setUiReadOnly(true);
} }
else if (attachedFractureDefinition()->orientation == RimFractureTemplate::AZIMUTH) else if (fractureTemplate()->orientationType == RimFractureTemplate::AZIMUTH)
{ {
azimuth.uiCapability()->setUiReadOnly(false); azimuth.uiCapability()->setUiReadOnly(false);
} }
if (attachedFractureDefinition()->orientation == RimFractureTemplate::ALONG_WELL_PATH) if (fractureTemplate()->orientationType == RimFractureTemplate::ALONG_WELL_PATH)
{ {
perforationEfficiency.uiCapability()->setUiHidden(false); perforationEfficiency.uiCapability()->setUiHidden(false);
perforationLength.uiCapability()->setUiHidden(false); perforationLength.uiCapability()->setUiHidden(false);
@ -447,7 +447,7 @@ void RimFracture::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiO
perforationLength.uiCapability()->setUiHidden(true); perforationLength.uiCapability()->setUiHidden(true);
} }
RimFractureTemplate* fracTemplate = attachedFractureDefinition(); RimFractureTemplate* fracTemplate = fractureTemplate();
if (dynamic_cast<RimStimPlanFractureTemplate*>(fracTemplate)) if (dynamic_cast<RimStimPlanFractureTemplate*>(fracTemplate))
{ {
stimPlanTimeIndexToPlot.uiCapability()->setUiHidden(false); stimPlanTimeIndexToPlot.uiCapability()->setUiHidden(false);
@ -516,10 +516,10 @@ void RimFracture::setAnchorPosition(const cvf::Vec3d& pos)
const RigMainGrid* mainGrid = activeRiv->mainGrid(); const RigMainGrid* mainGrid = activeRiv->mainGrid();
if (!mainGrid) return; if (!mainGrid) return;
cvf::BoundingBox polygonBBox; cvf::BoundingBox pointBBox;
polygonBBox.add(m_anchorPosition); pointBBox.add(m_anchorPosition);
mainGrid->findIntersectingCells(polygonBBox, &cellindecies); mainGrid->findIntersectingCells(pointBBox, &cellindecies);
if (cellindecies.size() > 0) if (cellindecies.size() > 0)
{ {
@ -531,9 +531,9 @@ void RimFracture::setAnchorPosition(const cvf::Vec3d& pos)
if (mainGrid->ijkFromCellIndex(gridCellIndex, &i, &j, &k)) if (mainGrid->ijkFromCellIndex(gridCellIndex, &i, &j, &k))
{ {
m_i = static_cast<int>(i); m_anchorPosEclipseCellI = static_cast<int>(i);
m_j = static_cast<int>(j); m_anchorPosEclipseCellJ = static_cast<int>(j);
m_k = static_cast<int>(k); m_anchorPosEclipseCellK = static_cast<int>(k);
} }
} }
} }
@ -556,19 +556,19 @@ void RimFracture::setFractureTemplate(RimFractureTemplate* fractureTemplate)
{ {
m_fractureTemplate = fractureTemplate; m_fractureTemplate = fractureTemplate;
RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(attachedFractureDefinition()); RimStimPlanFractureTemplate* stimPlanFracTemplate = dynamic_cast<RimStimPlanFractureTemplate*>(fractureTemplate);
if (stimPlanFracTemplate) if (stimPlanFracTemplate)
{ {
stimPlanTimeIndexToPlot = stimPlanFracTemplate->activeTimeStepIndex; stimPlanTimeIndexToPlot = stimPlanFracTemplate->activeTimeStepIndex;
} }
this->updateAzimuthFromFractureDefinition(); this->updateAzimuthFromFractureTemplate();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimFractureTemplate* RimFracture::attachedFractureDefinition() const RimFractureTemplate* RimFracture::fractureTemplate() const
{ {
return m_fractureTemplate(); return m_fractureTemplate();
} }
@ -578,9 +578,9 @@ RimFractureTemplate* RimFracture::attachedFractureDefinition() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RivWellFracturePartMgr* RimFracture::fracturePartManager() 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; const RigFracture* attachedRigFracture() const;
void setFractureTemplate(RimFractureTemplate* fractureTemplate); void setFractureTemplate(RimFractureTemplate* fractureTemplate);
RimFractureTemplate* attachedFractureDefinition() const; RimFractureTemplate* fractureTemplate() const;
RivWellFracturePartMgr* fracturePartManager(); RivWellFracturePartMgr* fracturePartManager();
@ -93,7 +93,7 @@ public:
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override; virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
cvf::Vec3d fracturePosition() const; cvf::Vec3d fracturePosition() const;
virtual void updateAzimuthFromFractureDefinition() = 0; virtual void updateAzimuthFromFractureTemplate() = 0;
virtual double wellAzimuthAtFracturePosition() = 0; virtual double wellAzimuthAtFracturePosition() = 0;
protected: protected:
@ -105,7 +105,7 @@ private:
bool isRecomputeGeometryFlagSet(); bool isRecomputeGeometryFlagSet();
cvf::Vec3d fracturePositionForUi() const; cvf::Vec3d fracturePositionForUi() const;
QString createOneBasedIJK() const; QString createOneBasedIJKText() const;
virtual cvf::BoundingBox boundingBoxInDomainCoords() override; virtual cvf::BoundingBox boundingBoxInDomainCoords() override;
@ -119,9 +119,9 @@ private:
cvf::ref<RigFracture> m_rigFracture; cvf::ref<RigFracture> m_rigFracture;
bool m_recomputeGeometry; bool m_recomputeGeometry;
caf::PdmField<int> m_i; // Zero based indexing caf::PdmField<int> m_anchorPosEclipseCellI; // Zero based indexing
caf::PdmField<int> m_j; // Zero based indexing caf::PdmField<int> m_anchorPosEclipseCellJ; // Zero based indexing
caf::PdmField<int> m_k; // 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", "", "", ""); CAF_PDM_InitField(&fractureTemplateUnit, "fractureTemplateUnit", caf::AppEnum<RimUnitSystem::UnitSystem>(RimUnitSystem::UNITS_METRIC), "Units System", "", "", "");
fractureTemplateUnit.uiCapability()->setUiReadOnly(true); 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(&azimuthAngle, "AzimuthAngle", 0.0f, "Azimuth Angle", "", "", ""); //Is this correct description?
CAF_PDM_InitField(&skinFactor, "SkinFactor", 1.0f, "Skin Factor", "", "", ""); CAF_PDM_InitField(&skinFactor, "SkinFactor", 1.0f, "Skin Factor", "", "", "");
@ -78,12 +78,12 @@ RimFractureTemplate::RimFractureTemplate(void)
perforationEfficiency.uiCapability()->setUiEditorTypeName(caf::PdmUiDoubleSliderEditor::uiEditorTypeName()); perforationEfficiency.uiCapability()->setUiEditorTypeName(caf::PdmUiDoubleSliderEditor::uiEditorTypeName());
CAF_PDM_InitField(&wellDiameter, "wellDiameter", 0.216, "Well Diameter at Fracture", "", "", ""); 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", "", "", ""); CAF_PDM_InitFieldNoDefault(&m_fractureContainment, "fractureContainmentField", "Fracture Containment", "", "", "");
m_fractureContainmentField = new RimFractureContainment(); m_fractureContainment = new RimFractureContainment();
m_fractureContainmentField.uiCapability()->setUiTreeHidden(true); m_fractureContainment.uiCapability()->setUiTreeHidden(true);
m_fractureContainmentField.uiCapability()->setUiTreeChildrenHidden(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) 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. //Changes to one of these parameters should change all fractures with this fracture template attached.
RimProject* proj; RimProject* proj;
@ -119,17 +119,17 @@ void RimFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
for (RimFracture* fracture : fractures) for (RimFracture* fracture : fractures)
{ {
if (fracture->attachedFractureDefinition() == this) if (fracture->fractureTemplate() == this)
{ {
if (changedField == &azimuthAngle && (abs(oldValue.toDouble() - fracture->azimuth()) < 1e-5)) if (changedField == &azimuthAngle && (abs(oldValue.toDouble() - fracture->azimuth()) < 1e-5))
{ {
fracture->updateAzimuthFromFractureDefinition(); fracture->updateAzimuthFromFractureTemplate();
fracture->setRecomputeGeometryFlag(); fracture->setRecomputeGeometryFlag();
} }
if (changedField == &orientation) if (changedField == &orientationType)
{ {
fracture->updateAzimuthFromFractureDefinition(); fracture->updateAzimuthFromFractureTemplate();
fracture->setRecomputeGeometryFlag(); fracture->setRecomputeGeometryFlag();
} }
@ -150,7 +150,7 @@ void RimFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
for (RimFracture* fracture : fractures) for (RimFracture* fracture : fractures)
{ {
if (fracture->attachedFractureDefinition() == this) if (fracture->fractureTemplate() == this)
{ {
if (changedField == &perforationLength && (abs(oldValue.toDouble() - fracture->perforationLength()) < 1e-5)) 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]"); perforationLength.uiCapability()->setUiName("Perforation Length [Ft]");
} }
if (orientation == RimFractureTemplate::ALONG_WELL_PATH if (orientationType == RimFractureTemplate::ALONG_WELL_PATH
|| orientation == RimFractureTemplate::TRANSVERSE_WELL_PATH) || orientationType == RimFractureTemplate::TRANSVERSE_WELL_PATH)
{ {
azimuthAngle.uiCapability()->setUiHidden(true); azimuthAngle.uiCapability()->setUiHidden(true);
} }
else if (orientation == RimFractureTemplate::AZIMUTH) else if (orientationType == RimFractureTemplate::AZIMUTH)
{ {
azimuthAngle.uiCapability()->setUiHidden(false); azimuthAngle.uiCapability()->setUiHidden(false);
} }
if (orientation == RimFractureTemplate::ALONG_WELL_PATH) if (orientationType == RimFractureTemplate::ALONG_WELL_PATH)
{ {
perforationEfficiency.uiCapability()->setUiHidden(false); perforationEfficiency.uiCapability()->setUiHidden(false);
perforationLength.uiCapability()->setUiHidden(false); perforationLength.uiCapability()->setUiHidden(false);

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

@ -62,26 +62,28 @@ public:
ALONG_WELL_PATH, ALONG_WELL_PATH,
TRANSVERSE_WELL_PATH TRANSVERSE_WELL_PATH
}; };
caf::PdmField< caf::AppEnum< FracOrientationEnum > > orientation; caf::PdmField< caf::AppEnum< FracOrientationEnum > > orientationType;
enum FracConductivityEnum enum FracConductivityEnum
{ {
INFINITE_CONDUCTIVITY, INFINITE_CONDUCTIVITY,
FINITE_CONDUCTIVITY, FINITE_CONDUCTIVITY,
}; };
caf::PdmField< caf::AppEnum< FracConductivityEnum > > fractureConductivity; caf::PdmField< caf::AppEnum< FracConductivityEnum > > conductivityType;
caf::PdmField< RimUnitSystem::UnitSystemType > fractureTemplateUnit; caf::PdmField< RimUnitSystem::UnitSystemType > fractureTemplateUnit;
void setDefaultWellDiameterFromUnit(); void setDefaultWellDiameterFromUnit();
virtual void fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimUnitSystem::UnitSystem fractureTemplateUnit) = 0; virtual void fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
virtual std::vector<cvf::Vec3f> fracturePolygon(RimUnitSystem::UnitSystem fractureTemplateUnit) = 0; 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; virtual const RigFractureGrid* fractureGrid() const = 0;
protected: protected:
caf::PdmChildField<RimFractureContainment*> m_fractureContainmentField; caf::PdmChildField<RimFractureContainment*> m_fractureContainment;
virtual caf::PdmFieldHandle* userDescriptionField() override; virtual caf::PdmFieldHandle* userDescriptionField() override;
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) 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; RimFractureTemplate::FracOrientationEnum orientation;
if (attachedFractureDefinition()) orientation = attachedFractureDefinition()->orientation(); if (fractureTemplate()) orientation = fractureTemplate()->orientationType();
else orientation = RimFractureTemplate::AZIMUTH; else orientation = RimFractureTemplate::AZIMUTH;
if (orientation == RimFractureTemplate::ALONG_WELL_PATH || orientation== RimFractureTemplate::TRANSVERSE_WELL_PATH) if (orientation == RimFractureTemplate::ALONG_WELL_PATH || orientation== RimFractureTemplate::TRANSVERSE_WELL_PATH)
@ -95,7 +95,7 @@ void RimSimWellFracture::updateAzimuthFromFractureDefinition()
} }
else //Azimuth value read from template else //Azimuth value read from template
{ {
if (attachedFractureDefinition()) azimuth = attachedFractureDefinition()->azimuthAngle; if (fractureTemplate()) azimuth = fractureTemplate()->azimuthAngle;
else azimuth = 0.0; else azimuth = 0.0;
} }
} }
@ -133,12 +133,12 @@ void RimSimWellFracture::fieldChangedByUi(const caf::PdmFieldHandle* changedFiel
updateFracturePositionFromLocation(); updateFracturePositionFromLocation();
RimFractureTemplate::FracOrientationEnum orientation; RimFractureTemplate::FracOrientationEnum orientation;
if (attachedFractureDefinition()) orientation = attachedFractureDefinition()->orientation(); if (fractureTemplate()) orientation = fractureTemplate()->orientationType();
else orientation = RimFractureTemplate::AZIMUTH; else orientation = RimFractureTemplate::AZIMUTH;
if (orientation != RimFractureTemplate::AZIMUTH) if (orientation != RimFractureTemplate::AZIMUTH)
{ {
updateAzimuthFromFractureDefinition(); updateAzimuthFromFractureTemplate();
} }
RimProject* proj; RimProject* proj;

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

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

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

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

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

@ -66,8 +66,10 @@ public:
const QString& fileName(); const QString& fileName();
QString fileNameWithOutPath(); QString fileNameWithOutPath();
void fractureGeometry(std::vector<cvf::Vec3f>* nodeCoords, std::vector<cvf::uint>* triangleIndices, RimUnitSystem::UnitSystem fractureUnit) override; void fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::Vec3f> fracturePolygon(RimUnitSystem::UnitSystem fractureUnit); std::vector<cvf::uint>* triangleIndices,
RimUnitSystem::UnitSystem neededUnit) override;
std::vector<cvf::Vec3f> fractureBorderPolygon(RimUnitSystem::UnitSystem neededUnit);
void sortPolygon(std::vector<cvf::Vec3f> &polygon); void sortPolygon(std::vector<cvf::Vec3f> &polygon);
std::vector<double> getStimPlanTimeValues(); 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) if (changedField == &m_measuredDepth)
{ {
updatePositionFromMeasuredDepth(); updatePositionFromMeasuredDepth();
updateAzimuthFromFractureDefinition(); updateAzimuthFromFractureTemplate();
RimProject* proj = nullptr; RimProject* proj = nullptr;
this->firstAncestorOrThisOfType(proj); this->firstAncestorOrThisOfType(proj);
@ -87,10 +87,10 @@ void RimWellPathFracture::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPathFracture::updateAzimuthFromFractureDefinition() void RimWellPathFracture::updateAzimuthFromFractureTemplate()
{ {
RimFractureTemplate::FracOrientationEnum orientation; RimFractureTemplate::FracOrientationEnum orientation;
if (attachedFractureDefinition()) orientation = attachedFractureDefinition()->orientation(); if (fractureTemplate()) orientation = fractureTemplate()->orientationType();
else orientation = RimFractureTemplate::AZIMUTH; else orientation = RimFractureTemplate::AZIMUTH;
if (orientation == RimFractureTemplate::ALONG_WELL_PATH || orientation == RimFractureTemplate::TRANSVERSE_WELL_PATH) 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! //TODO: Reset value if choosing azimuth in frac template!
// else //Azimuth value read from 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); void setMeasuredDepth(double mdValue);
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override; 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; double wellAzimuthAtFracturePosition() override;

6
ApplicationCode/ReservoirDataModel/RigFractureTransCalc.cpp
View File

@ -85,7 +85,7 @@ RigFractureTransCalc::RigFractureTransCalc(RimEclipseCase* caseToApply, RimFract
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<RigFracturedEclipseCellExportData> RigFractureTransCalc::computeTransmissibilityFromPolygonWithInfiniteConductivityInFracture() 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("Transimssibility for finite conductity in fracture not yet implemented."));
RiaLogging::warning(QString("Performing calculation for infinite conductivity instead.")); RiaLogging::warning(QString("Performing calculation for infinite conductivity instead."));
@ -166,7 +166,7 @@ std::vector<RigFracturedEclipseCellExportData> RigFractureTransCalc::computeTra
RigFracturedEclipseCellExportData fracData; RigFracturedEclipseCellExportData fracData;
fracData.reservoirCellIndex = fracCell; 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; std::vector<cvf::Vec3d> fracPolygonDouble;
for (auto v : fracPolygon) fracPolygonDouble.push_back(static_cast<cvf::Vec3d>(v)); 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; for (double lengtXarea : lengthXareaOfFractureParts) totalAreaXLength += lengtXarea;
double fractureAreaWeightedlength = totalAreaXLength / fractureArea; 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_X = RigFractureTransmissibilityEquations::matrixToFractureTrans(permY, NTG, Ay, dx, skinfactor, fractureAreaWeightedlength, cDarchy);
double transmissibility_Y = RigFractureTransmissibilityEquations::matrixToFractureTrans(permX, NTG, Ax, dy, 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) std::pair<double, double> RigStimPlanUpscalingCalc::flowAcrossLayersUpscaling(QString resultName, QString resultUnit, size_t timeStepIndex, RimUnitSystem::UnitSystem unitSystem, size_t eclipseCellIndex)
{ {
RimStimPlanFractureTemplate* fracTemplateStimPlan; 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); 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); directionAcrossLayers = cvf::Vec3d(0.0, -1.0, 0.0);
directionAlongLayers = cvf::Vec3d(1.0, 0.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<std::vector<cvf::Vec3d> > polygonsDescribingFractureInCell;
std::vector<double> upscaledConductivitiesHA; std::vector<double> upscaledConductivitiesHA;
@ -273,9 +273,9 @@ std::vector<RigFracturedEclipseCellExportData> RigStimPlanUpscalingCalc::comput
std::vector<RigFracturedEclipseCellExportData> fracDataVec; std::vector<RigFracturedEclipseCellExportData> fracDataVec;
RimStimPlanFractureTemplate* fracTemplateStimPlan; 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 else
{ {

2
ApplicationCode/ReservoirDataModel/RigWellPathStimplanIntersector.cpp
View File

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