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

#3197 Refactoring : Whitespace

Browse Source
This commit is contained in:
Magne Sjaastad 2018-08-10 14:47:06 +02:00
parent a672e1fa7f
commit b111b87e41
3 changed files with 295 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -38,10 +38,8 @@
#include "cafPdmObject.h" #include "cafPdmObject.h"
#include "cvfVector3.h"
#include "cvfGeometryTools.h" #include "cvfGeometryTools.h"
#include "cvfVector3.h"
CAF_PDM_SOURCE_INIT(RimEllipseFractureTemplate, "RimEllipseFractureTemplate"); CAF_PDM_SOURCE_INIT(RimEllipseFractureTemplate, "RimEllipseFractureTemplate");
@ -50,7 +48,9 @@ CAF_PDM_SOURCE_INIT(RimEllipseFractureTemplate, "RimEllipseFractureTemplate");
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimEllipseFractureTemplate::RimEllipseFractureTemplate() RimEllipseFractureTemplate::RimEllipseFractureTemplate()
{ {
CAF_PDM_InitObject("Fracture Template", ":/FractureTemplate16x16.png", "", ""); // clang-format off
CAF_PDM_InitObject("Fracture Template", ":/FractureTemplate16x16.png", "", "");
CAF_PDM_InitField(&m_halfLength, "HalfLength", 0.0, "Halflength X<sub>f</sub>", "", "", ""); CAF_PDM_InitField(&m_halfLength, "HalfLength", 0.0, "Halflength X<sub>f</sub>", "", "", "");
CAF_PDM_InitField(&m_height, "Height", 0.0, "Height", "", "", ""); CAF_PDM_InitField(&m_height, "Height", 0.0, "Height", "", "", "");
@ -59,14 +59,14 @@ RimEllipseFractureTemplate::RimEllipseFractureTemplate()
m_fractureGrid = new RigFractureGrid(); m_fractureGrid = new RigFractureGrid();
assignConductivityToCellsInsideEllipse(); assignConductivityToCellsInsideEllipse();
// clang-format on
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimEllipseFractureTemplate::~RimEllipseFractureTemplate() RimEllipseFractureTemplate::~RimEllipseFractureTemplate() {}
{
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
@ -82,19 +82,18 @@ void RimEllipseFractureTemplate::loadDataAndUpdate()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) void RimEllipseFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
const QVariant& oldValue,
const QVariant& newValue)
{ {
RimFractureTemplate::fieldChangedByUi(changedField, oldValue, newValue); RimFractureTemplate::fieldChangedByUi(changedField, oldValue, newValue);
if ( changedField == &m_halfLength if (changedField == &m_halfLength || changedField == &m_height || changedField == &m_width ||
|| changedField == &m_height changedField == &m_permeability || changedField == &m_scaleApplyButton)
|| changedField == &m_width
|| changedField == &m_permeability
|| changedField == &m_scaleApplyButton)
{ {
m_scaleApplyButton = false; m_scaleApplyButton = false;
//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.
reload(); reload();
} }
@ -108,7 +107,7 @@ void RimEllipseFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* cha
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords, void RimEllipseFractureTemplate::fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* triangleIndices) const std::vector<cvf::uint>* triangleIndices) const
{ {
RigEllipsisTesselator tesselator(20); RigEllipsisTesselator tesselator(20);
@ -165,24 +164,23 @@ void RimEllipseFractureTemplate::assignConductivityToCellsInsideEllipse()
int numberOfCellsI = 35; int numberOfCellsI = 35;
int numberOfCellsJ = 35; int numberOfCellsJ = 35;
double height = m_height * m_heightScaleFactor; double height = m_height * m_heightScaleFactor;
double halfLength = m_halfLength * m_widthScaleFactor; double halfLength = m_halfLength * m_widthScaleFactor;
double cellSizeX = (halfLength * 2) / numberOfCellsI * m_widthScaleFactor; double cellSizeX = (halfLength * 2) / numberOfCellsI * m_widthScaleFactor;
double cellSizeZ = height / numberOfCellsJ * m_heightScaleFactor; double cellSizeZ = height / numberOfCellsJ * m_heightScaleFactor;
double cellArea = cellSizeX * cellSizeZ; double cellArea = cellSizeX * cellSizeZ;
double areaTresholdForIncludingCell = 0.5 * cellArea; double areaTresholdForIncludingCell = 0.5 * cellArea;
for (int i = 0; i < numberOfCellsI; i++) for (int i = 0; i < numberOfCellsI; i++)
{ {
for (int j = 0; j < numberOfCellsJ; j++) for (int j = 0; j < numberOfCellsJ; j++)
{ {
double X1 = - halfLength + i * cellSizeX; double X1 = -halfLength + i * cellSizeX;
double X2 = - halfLength + (i+1) * cellSizeX; double X2 = -halfLength + (i + 1) * cellSizeX;
double Y1 = - height / 2 + j * cellSizeZ; double Y1 = -height / 2 + j * cellSizeZ;
double Y2 = - height / 2 + (j+1) * cellSizeZ; double Y2 = -height / 2 + (j + 1) * cellSizeZ;
std::vector<cvf::Vec3d> cellPolygon; std::vector<cvf::Vec3d> cellPolygon;
cellPolygon.push_back(cvf::Vec3d(X1, Y1, 0.0)); cellPolygon.push_back(cvf::Vec3d(X1, Y1, 0.0));
@ -194,17 +192,24 @@ void RimEllipseFractureTemplate::assignConductivityToCellsInsideEllipse()
std::vector<cvf::Vec3f> ellipseFracPolygon = fractureBorderPolygon(); std::vector<cvf::Vec3f> ellipseFracPolygon = fractureBorderPolygon();
std::vector<cvf::Vec3d> ellipseFracPolygonDouble; std::vector<cvf::Vec3d> ellipseFracPolygonDouble;
for (const auto& v : ellipseFracPolygon) ellipseFracPolygonDouble.push_back(static_cast<cvf::Vec3d>(v)); for (const auto& v : ellipseFracPolygon)
std::vector<std::vector<cvf::Vec3d> >clippedFracturePolygons = RigCellGeometryTools::intersectPolygons(cellPolygon, ellipseFracPolygonDouble); ellipseFracPolygonDouble.push_back(static_cast<cvf::Vec3d>(v));
std::vector<std::vector<cvf::Vec3d>> clippedFracturePolygons =
RigCellGeometryTools::intersectPolygons(cellPolygon, ellipseFracPolygonDouble);
if (!clippedFracturePolygons.empty()) if (!clippedFracturePolygons.empty())
{ {
for (const auto& clippedFracturePolygon : clippedFracturePolygons) for (const auto& clippedFracturePolygon : clippedFracturePolygons)
{ {
double areaCutPolygon = cvf::GeometryTools::polygonAreaNormal3D(clippedFracturePolygon).length(); double areaCutPolygon = cvf::GeometryTools::polygonAreaNormal3D(clippedFracturePolygon).length();
if (areaCutPolygon < areaTresholdForIncludingCell) cond = 0.0; //Cell is excluded from calculation, cond is set to zero. Must be included for indexing to be correct if (areaCutPolygon < areaTresholdForIncludingCell)
{
cond = 0.0; // Cell is excluded from calculation, cond is set to zero. Must be included for indexing to be
// correct
}
} }
} }
else cond = 0.0; else
cond = 0.0;
RigFractureCell fractureCell(cellPolygon, i, j); RigFractureCell fractureCell(cellPolygon, i, j);
fractureCell.setConductivityValue(cond); fractureCell.setConductivityValue(cond);
@ -229,7 +234,7 @@ void RimEllipseFractureTemplate::assignConductivityToCellsInsideEllipse()
FractureWidthAndConductivity RimEllipseFractureTemplate::widthAndConductivityAtWellPathIntersection() const FractureWidthAndConductivity RimEllipseFractureTemplate::widthAndConductivityAtWellPathIntersection() const
{ {
FractureWidthAndConductivity values; FractureWidthAndConductivity values;
values.m_width = m_width; values.m_width = m_width;
values.m_permeability = m_permeability; values.m_permeability = m_permeability;
return values; return values;
@ -274,12 +279,12 @@ double RimEllipseFractureTemplate::conductivity() const
double cond = cvf::UNDEFINED_DOUBLE; double cond = cvf::UNDEFINED_DOUBLE;
if (fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_METRIC) if (fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_METRIC)
{ {
//Conductivity should be md-m, width is in m // Conductivity should be md-m, width is in m
cond = m_permeability * m_width; cond = m_permeability * m_width;
} }
else if (fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD) else if (fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD)
{ {
//Conductivity should be md-ft, but width is in inches // Conductivity should be md-ft, but width is in inches
cond = m_permeability * RiaEclipseUnitTools::inchToFeet(m_width); cond = m_permeability * RiaEclipseUnitTools::inchToFeet(m_width);
} }
@ -313,7 +318,10 @@ double RimEllipseFractureTemplate::width() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimEllipseFractureTemplate::appendDataToResultStatistics(const QString& uiResultName, const QString& unit, MinMaxAccumulator& minMaxAccumulator, PosNegAccumulator& posNegAccumulator) const void RimEllipseFractureTemplate::appendDataToResultStatistics(const QString& uiResultName,
const QString& unit,
MinMaxAccumulator& minMaxAccumulator,
PosNegAccumulator& posNegAccumulator) const
{ {
if (uiResultName == RiaDefines::conductivityResultName()) if (uiResultName == RiaDefines::conductivityResultName())
{ {
@ -361,15 +369,15 @@ void RimEllipseFractureTemplate::convertToUnitSystem(RiaEclipseUnitTools::UnitSy
if (neededUnit == RiaEclipseUnitTools::UNITS_FIELD) if (neededUnit == RiaEclipseUnitTools::UNITS_FIELD)
{ {
m_halfLength = RiaEclipseUnitTools::meterToFeet(m_halfLength); m_halfLength = RiaEclipseUnitTools::meterToFeet(m_halfLength);
m_height = RiaEclipseUnitTools::meterToFeet(m_height); m_height = RiaEclipseUnitTools::meterToFeet(m_height);
m_width = RiaEclipseUnitTools::meterToInch(m_width); m_width = RiaEclipseUnitTools::meterToInch(m_width);
} }
else if (neededUnit == RiaEclipseUnitTools::UNITS_METRIC) else if (neededUnit == RiaEclipseUnitTools::UNITS_METRIC)
{ {
m_halfLength = RiaEclipseUnitTools::feetToMeter(m_halfLength); m_halfLength = RiaEclipseUnitTools::feetToMeter(m_halfLength);
m_height = RiaEclipseUnitTools::feetToMeter(m_height); m_height = RiaEclipseUnitTools::feetToMeter(m_height);
m_width = RiaEclipseUnitTools::inchToMeter(m_width); m_width = RiaEclipseUnitTools::inchToMeter(m_width);
} }
} }
@ -425,4 +433,3 @@ void RimEllipseFractureTemplate::defineUiOrdering(QString uiConfigName, caf::Pdm
RimFractureTemplate::defineUiOrdering(uiConfigName, uiOrdering); RimFractureTemplate::defineUiOrdering(uiConfigName, uiOrdering);
} }

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

@ -28,13 +28,15 @@
#include "cafPdmObject.h" #include "cafPdmObject.h"
#include "cafPdmUiDoubleSliderEditor.h" #include "cafPdmUiDoubleSliderEditor.h"
#include "cafPdmUiDoubleValueEditor.h" #include "cafPdmUiDoubleValueEditor.h"
#include "cafPdmUiTextEditor.h"
#include "cafPdmUiPushButtonEditor.h" #include "cafPdmUiPushButtonEditor.h"
#include "cafPdmUiTextEditor.h"
#include "cvfVector3.h" #include "cvfVector3.h"
#include <cmath> #include <cmath>
// clang-format off
namespace caf namespace caf
{ {
template<> template<>
@ -169,12 +171,12 @@ RimFractureTemplate::RimFractureTemplate()
m_scaleApplyButton.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN); m_scaleApplyButton.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
} }
// clang-format on
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimFractureTemplate::~RimFractureTemplate() RimFractureTemplate::~RimFractureTemplate() {}
{
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
@ -235,17 +237,19 @@ 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)
{ {
bool createDisplayModelAndRedraw = false; bool createDisplayModelAndRedraw = false;
if (changedField == &m_azimuthAngle || changedField == &m_orientationType) if (changedField == &m_azimuthAngle || changedField == &m_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;
this->firstAncestorOrThisOfType(proj); this->firstAncestorOrThisOfType(proj);
if (proj) if (proj)
{ {
//Regenerate geometry // Regenerate geometry
std::vector<RimFracture*> fractures; std::vector<RimFracture*> fractures;
proj->descendantsIncludingThisOfType(fractures); proj->descendantsIncludingThisOfType(fractures);
@ -264,7 +268,10 @@ void RimFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
{ {
fracture->m_azimuth = m_azimuthAngle; fracture->m_azimuth = m_azimuthAngle;
} }
else fracture->updateAzimuthBasedOnWellAzimuthAngle(); else
{
fracture->updateAzimuthBasedOnWellAzimuthAngle();
}
} }
} }
} }
@ -289,7 +296,8 @@ void RimFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
{ {
fracture->m_perforationLength = m_perforationLength; fracture->m_perforationLength = m_perforationLength;
} }
if (changedField == &m_perforationEfficiency && (fabs(oldValue.toDouble() - fracture->m_perforationEfficiency()) < 1e-5)) if (changedField == &m_perforationEfficiency &&
(fabs(oldValue.toDouble() - fracture->m_perforationEfficiency()) < 1e-5))
{ {
fracture->m_perforationEfficiency = m_perforationEfficiency; fracture->m_perforationEfficiency = m_perforationEfficiency;
} }
@ -365,7 +373,7 @@ void RimFractureTemplate::defineUiOrdering(QString uiConfigName, caf::PdmUiOrder
nonDarcyFlowGroup->add(&m_dFactorDisplayField); nonDarcyFlowGroup->add(&m_dFactorDisplayField);
{ {
auto group = nonDarcyFlowGroup->addNewGroup("D Factor Details"); auto group = nonDarcyFlowGroup->addNewGroup("D Factor Details");
group->setCollapsedByDefault(true); group->setCollapsedByDefault(true);
group->add(&m_dFactorSummaryText); group->add(&m_dFactorSummaryText);
} }
@ -378,7 +386,9 @@ void RimFractureTemplate::defineUiOrdering(QString uiConfigName, caf::PdmUiOrder
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimFractureTemplate::defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute) void RimFractureTemplate::defineEditorAttribute(const caf::PdmFieldHandle* field,
QString uiConfigName,
caf::PdmUiEditorAttribute* attribute)
{ {
if (field == &m_perforationEfficiency) if (field == &m_perforationEfficiency)
{ {
@ -398,14 +408,14 @@ void RimFractureTemplate::defineEditorAttribute(const caf::PdmFieldHandle* field
myAttr->wrapMode = caf::PdmUiTextEditorAttribute::NoWrap; myAttr->wrapMode = caf::PdmUiTextEditorAttribute::NoWrap;
QFont font("Monospace", 10); QFont font("Monospace", 10);
myAttr->font = font; myAttr->font = font;
myAttr->textMode = caf::PdmUiTextEditorAttribute::HTML; myAttr->textMode = caf::PdmUiTextEditorAttribute::HTML;
} }
} }
if (field == &m_scaleApplyButton) if (field == &m_scaleApplyButton)
{ {
caf::PdmUiPushButtonEditorAttribute* attrib = dynamic_cast<caf::PdmUiPushButtonEditorAttribute*> (attribute); caf::PdmUiPushButtonEditorAttribute* attrib = dynamic_cast<caf::PdmUiPushButtonEditorAttribute*>(attribute);
if (attrib) if (attrib)
{ {
attrib->m_buttonText = "Apply"; attrib->m_buttonText = "Apply";
@ -457,8 +467,8 @@ void RimFractureTemplate::prepareFieldsForUiDisplay()
m_fractureWidth.uiCapability()->setUiName("Fracture Width [ft]"); m_fractureWidth.uiCapability()->setUiName("Fracture Width [ft]");
} }
if (m_orientationType == RimFractureTemplate::ALONG_WELL_PATH if (m_orientationType == RimFractureTemplate::ALONG_WELL_PATH ||
|| m_orientationType == RimFractureTemplate::TRANSVERSE_WELL_PATH) m_orientationType == RimFractureTemplate::TRANSVERSE_WELL_PATH)
{ {
m_azimuthAngle.uiCapability()->setUiHidden(true); m_azimuthAngle.uiCapability()->setUiHidden(true);
} }
@ -572,7 +582,7 @@ double RimFractureTemplate::effectivePermeability() const
else else
{ {
double fracPermeability = 0.0; double fracPermeability = 0.0;
auto values = widthAndConductivityAtWellPathIntersection(); auto values = widthAndConductivityAtWellPathIntersection();
if (values.isWidthAndPermeabilityDefined()) if (values.isWidthAndPermeabilityDefined())
{ {
fracPermeability = values.m_permeability; fracPermeability = values.m_permeability;
@ -580,7 +590,7 @@ double RimFractureTemplate::effectivePermeability() const
else else
{ {
auto conductivity = values.m_conductivity; auto conductivity = values.m_conductivity;
auto width = fractureWidth(); auto width = fractureWidth();
if (fabs(width) < 1e-10) return HUGE_VAL; if (fabs(width) < 1e-10) return HUGE_VAL;
@ -604,16 +614,16 @@ double RimFractureTemplate::dFactor() const
} }
else else
{ {
auto alpha = RiaDefines::nonDarcyFlowAlpha(m_fractureTemplateUnit()); auto alpha = RiaDefines::nonDarcyFlowAlpha(m_fractureTemplateUnit());
auto beta = m_inertialCoefficient; auto beta = m_inertialCoefficient;
auto effPerm = effectivePermeability(); auto effPerm = effectivePermeability();
auto gamma = m_relativeGasDensity; auto gamma = m_relativeGasDensity;
auto radius = m_wellDiameter / 2.0; auto radius = m_wellDiameter / 2.0;
auto mu = m_gasViscosity; auto mu = m_gasViscosity;
auto h = fractureWidth(); auto h = fractureWidth();
double numerator = alpha * beta * effPerm * gamma; double numerator = alpha * beta * effPerm * gamma;
double denumerator = h * radius * mu; double denumerator = h * radius * mu;
if (denumerator < 1e-10) return HUGE_VAL; if (denumerator < 1e-10) return HUGE_VAL;
@ -702,22 +712,25 @@ void RimFractureTemplate::setId(int id)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimFractureTemplate::setScaleFactors(double widthScale, double heightScale, double dFactorScale, double conductivityScale) void RimFractureTemplate::setScaleFactors(double widthScale, double heightScale, double dFactorScale, double conductivityScale)
{ {
m_widthScaleFactor = widthScale; m_widthScaleFactor = widthScale;
m_heightScaleFactor = heightScale; m_heightScaleFactor = heightScale;
m_dFactorScaleFactor = dFactorScale; m_dFactorScaleFactor = dFactorScale;
m_conductivityScaleFactor = conductivityScale; m_conductivityScaleFactor = conductivityScale;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimFractureTemplate::scaleFactors(double* widthScale, double* heightScale, double* dFactorScale, double* conductivityScale) const void RimFractureTemplate::scaleFactors(double* widthScale,
double* heightScale,
double* dFactorScale,
double* conductivityScale) const
{ {
CVF_ASSERT(widthScale && heightScale && dFactorScale && conductivityScale); CVF_ASSERT(widthScale && heightScale && dFactorScale && conductivityScale);
*widthScale = m_widthScaleFactor; *widthScale = m_widthScaleFactor;
*heightScale = m_widthScaleFactor; *heightScale = m_widthScaleFactor;
*dFactorScale = m_dFactorScaleFactor; *dFactorScale = m_dFactorScaleFactor;
*conductivityScale = m_conductivityScaleFactor; *conductivityScale = m_conductivityScaleFactor;
} }
@ -792,7 +805,7 @@ double RimFractureTemplate::perforationLength() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
const RimFractureContainment * RimFractureTemplate::fractureContainment() const const RimFractureContainment* RimFractureTemplate::fractureContainment() const
{ {
return m_fractureContainment(); return m_fractureContainment();
} }

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

@ -24,8 +24,8 @@
#include "RifStimPlanXmlReader.h" #include "RifStimPlanXmlReader.h"
#include "RigStimPlanFractureDefinition.h"
#include "RigFractureGrid.h" #include "RigFractureGrid.h"
#include "RigStimPlanFractureDefinition.h"
#include "RigFractureCell.h" #include "RigFractureCell.h"
#include "RimEclipseView.h" #include "RimEclipseView.h"
@ -47,8 +47,8 @@
#include <QFileInfo> #include <QFileInfo>
#include <algorithm> #include <algorithm>
#include <vector>
#include <cmath> #include <cmath>
#include <vector>
static std::vector<double> EMPTY_DOUBLE_VECTOR; static std::vector<double> EMPTY_DOUBLE_VECTOR;
@ -59,6 +59,8 @@ CAF_PDM_SOURCE_INIT(RimStimPlanFractureTemplate, "RimStimPlanFractureTemplate");
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimStimPlanFractureTemplate::RimStimPlanFractureTemplate() RimStimPlanFractureTemplate::RimStimPlanFractureTemplate()
{ {
// clang-format off
CAF_PDM_InitObject("Fracture Template", ":/FractureTemplate16x16.png", "", ""); CAF_PDM_InitObject("Fracture Template", ":/FractureTemplate16x16.png", "", "");
CAF_PDM_InitField(&m_stimPlanFileName, "StimPlanFileName", QString(""), "File Name", "", "", ""); CAF_PDM_InitField(&m_stimPlanFileName, "StimPlanFileName", QString(""), "File Name", "", "", "");
@ -82,14 +84,14 @@ RimStimPlanFractureTemplate::RimStimPlanFractureTemplate()
m_areaWeightedConductivity = 0.0; m_areaWeightedConductivity = 0.0;
m_areaWeightedWidth = 0.0; m_areaWeightedWidth = 0.0;
m_longestYRangeAboveConductivityThreshold = 0.0; m_longestYRangeAboveConductivityThreshold = 0.0;
// clang-format on
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimStimPlanFractureTemplate::~RimStimPlanFractureTemplate() RimStimPlanFractureTemplate::~RimStimPlanFractureTemplate() {}
{
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
@ -102,7 +104,9 @@ int RimStimPlanFractureTemplate::activeTimeStepIndex()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimStimPlanFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) void RimStimPlanFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
const QVariant& oldValue,
const QVariant& newValue)
{ {
RimFractureTemplate::fieldChangedByUi(changedField, oldValue, newValue); RimFractureTemplate::fieldChangedByUi(changedField, oldValue, newValue);
@ -115,7 +119,7 @@ void RimStimPlanFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* ch
if (&m_activeTimeStepIndex == changedField) if (&m_activeTimeStepIndex == changedField)
{ {
//Changes to this parameters should change all fractures with this fracture template attached. // Changes to this parameters should change all fractures with this fracture template attached.
RimProject* proj; RimProject* proj;
this->firstAncestorOrThisOfType(proj); this->firstAncestorOrThisOfType(proj);
if (proj) if (proj)
@ -133,11 +137,9 @@ void RimStimPlanFractureTemplate::fieldChangedByUi(const caf::PdmFieldHandle* ch
} }
} }
if (&m_wellPathDepthAtFracture == changedField if (&m_wellPathDepthAtFracture == changedField || &m_borderPolygonResultName == changedField ||
|| &m_borderPolygonResultName == changedField &m_activeTimeStepIndex == changedField || &m_stimPlanFileName == changedField ||
|| &m_activeTimeStepIndex == changedField &m_conductivityResultNameOnFile == changedField)
|| &m_stimPlanFileName == changedField
|| &m_conductivityResultNameOnFile == changedField)
{ {
updateFractureGrid(); updateFractureGrid();
@ -195,8 +197,12 @@ void RimStimPlanFractureTemplate::setDefaultsBasedOnXMLfile()
m_activeTimeStepIndex = static_cast<int>(m_stimPlanFractureDefinitionData->totalNumberTimeSteps() - 1); m_activeTimeStepIndex = static_cast<int>(m_stimPlanFractureDefinitionData->totalNumberTimeSteps() - 1);
bool polygonPropertySet = setBorderPolygonResultNameToDefault(); bool polygonPropertySet = setBorderPolygonResultNameToDefault();
if (polygonPropertySet) RiaLogging::info(QString("Calculating polygon outline based on %1 at timestep %2").arg(m_borderPolygonResultName).arg(m_stimPlanFractureDefinitionData->timeSteps()[m_activeTimeStepIndex])); if (polygonPropertySet)
else RiaLogging::info(QString("Property for polygon calculation not set.")); RiaLogging::info(QString("Calculating polygon outline based on %1 at timestep %2")
.arg(m_borderPolygonResultName)
.arg(m_stimPlanFractureDefinitionData->timeSteps()[m_activeTimeStepIndex]));
else
RiaLogging::info(QString("Property for polygon calculation not set."));
if (!m_stimPlanFractureDefinitionData->conductivityResultNames().isEmpty()) if (!m_stimPlanFractureDefinitionData->conductivityResultNames().isEmpty())
{ {
@ -244,7 +250,7 @@ void RimStimPlanFractureTemplate::loadDataAndUpdate()
if (m_readError) return; if (m_readError) return;
m_stimPlanFractureDefinitionData = RifStimPlanXmlReader::readStimPlanXMLFile( m_stimPlanFileName(), m_stimPlanFractureDefinitionData = RifStimPlanXmlReader::readStimPlanXMLFile(m_stimPlanFileName(),
m_conductivityScaleFactor(), m_conductivityScaleFactor(),
m_widthScaleFactor(), m_widthScaleFactor(),
m_heightScaleFactor(), m_heightScaleFactor(),
@ -283,7 +289,8 @@ void RimStimPlanFractureTemplate::loadDataAndUpdate()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RimStimPlanFractureTemplate::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly) QList<caf::PdmOptionItemInfo> RimStimPlanFractureTemplate::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions,
bool* useOptionsOnly)
{ {
QList<caf::PdmOptionItemInfo> options; QList<caf::PdmOptionItemInfo> options;
@ -329,7 +336,7 @@ void RimStimPlanFractureTemplate::computeDepthOfWellPathAtFracture()
if (!m_stimPlanFractureDefinitionData.isNull()) if (!m_stimPlanFractureDefinitionData.isNull())
{ {
double firstTvd = m_stimPlanFractureDefinitionData->topPerfTvd(); double firstTvd = m_stimPlanFractureDefinitionData->topPerfTvd();
double lastTvd = m_stimPlanFractureDefinitionData->bottomPerfTvd(); double lastTvd = m_stimPlanFractureDefinitionData->bottomPerfTvd();
if (firstTvd != HUGE_VAL && lastTvd != HUGE_VAL) if (firstTvd != HUGE_VAL && lastTvd != HUGE_VAL)
{ {
@ -337,8 +344,8 @@ void RimStimPlanFractureTemplate::computeDepthOfWellPathAtFracture()
} }
else else
{ {
firstTvd = m_stimPlanFractureDefinitionData->minDepth(); firstTvd = m_stimPlanFractureDefinitionData->minDepth();
lastTvd = m_stimPlanFractureDefinitionData->maxDepth(); lastTvd = m_stimPlanFractureDefinitionData->maxDepth();
m_wellPathDepthAtFracture = (firstTvd + lastTvd) / 2; m_wellPathDepthAtFracture = (firstTvd + lastTvd) / 2;
} }
} }
@ -352,7 +359,7 @@ void RimStimPlanFractureTemplate::computePerforationLength()
if (!m_stimPlanFractureDefinitionData.isNull()) if (!m_stimPlanFractureDefinitionData.isNull())
{ {
double firstTvd = m_stimPlanFractureDefinitionData->topPerfTvd(); double firstTvd = m_stimPlanFractureDefinitionData->topPerfTvd();
double lastTvd = m_stimPlanFractureDefinitionData->bottomPerfTvd(); double lastTvd = m_stimPlanFractureDefinitionData->bottomPerfTvd();
if (firstTvd != HUGE_VAL && lastTvd != HUGE_VAL) if (firstTvd != HUGE_VAL && lastTvd != HUGE_VAL)
{ {
@ -364,7 +371,8 @@ void RimStimPlanFractureTemplate::computePerforationLength()
{ {
m_perforationLength = 10; m_perforationLength = 10;
} }
else if (fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD && m_perforationLength < RiaEclipseUnitTools::meterToFeet(10)) else if (fractureTemplateUnit() == RiaEclipseUnitTools::UNITS_FIELD &&
m_perforationLength < RiaEclipseUnitTools::meterToFeet(10))
{ {
m_perforationLength = std::round(RiaEclipseUnitTools::meterToFeet(10)); m_perforationLength = std::round(RiaEclipseUnitTools::meterToFeet(10));
} }
@ -376,25 +384,24 @@ void RimStimPlanFractureTemplate::computePerforationLength()
QString RimStimPlanFractureTemplate::getUnitForStimPlanParameter(QString parameterName) QString RimStimPlanFractureTemplate::getUnitForStimPlanParameter(QString parameterName)
{ {
QString unit; QString unit;
bool found = false; bool found = false;
bool foundMultiple = false; bool foundMultiple = false;
for (std::pair<QString, QString> nameUnit : uiResultNamesWithUnit()) for (std::pair<QString, QString> nameUnit : uiResultNamesWithUnit())
{ {
if (nameUnit.first == parameterName) if (nameUnit.first == parameterName)
{ {
unit = nameUnit.second; unit = nameUnit.second;
if (found) foundMultiple = true; if (found) foundMultiple = true;
found = true; found = true;
} }
} }
if (foundMultiple) RiaLogging::error(QString("Multiple units found for same parameter")); if (foundMultiple) RiaLogging::error(QString("Multiple units found for same parameter"));
if (!found) RiaLogging::error(QString("Requested unit / parameter not found for %1 template").arg(name())); if (!found) RiaLogging::error(QString("Requested unit / parameter not found for %1 template").arg(name()));
return unit; return unit;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -404,11 +411,11 @@ FractureWidthAndConductivity RimStimPlanFractureTemplate::widthAndConductivityAt
if (m_fractureGrid.notNull()) if (m_fractureGrid.notNull())
{ {
std::pair<size_t, size_t> wellCellIJ = m_fractureGrid->fractureCellAtWellCenter(); std::pair<size_t, size_t> wellCellIJ = m_fractureGrid->fractureCellAtWellCenter();
size_t wellCellIndex = m_fractureGrid->getGlobalIndexFromIJ(wellCellIJ.first, wellCellIJ.second); size_t wellCellIndex = m_fractureGrid->getGlobalIndexFromIJ(wellCellIJ.first, wellCellIJ.second);
const RigFractureCell& wellCell = m_fractureGrid->cellFromIndex(wellCellIndex); const RigFractureCell& wellCell = m_fractureGrid->cellFromIndex(wellCellIndex);
double conductivity = wellCell.getConductivityValue(); double conductivity = wellCell.getConductivityValue();
values.m_conductivity = conductivity; values.m_conductivity = conductivity;
auto nameUnit = widthParameterNameAndUnit(); auto nameUnit = widthParameterNameAndUnit();
@ -416,7 +423,8 @@ FractureWidthAndConductivity RimStimPlanFractureTemplate::widthAndConductivityAt
{ {
double widthInRequiredUnit = HUGE_VAL; double widthInRequiredUnit = HUGE_VAL;
{ {
auto resultValues = m_stimPlanFractureDefinitionData->fractureGridResults(nameUnit.first, nameUnit.second, m_activeTimeStepIndex); auto resultValues =
m_stimPlanFractureDefinitionData->fractureGridResults(nameUnit.first, nameUnit.second, m_activeTimeStepIndex);
double widthInFileUnitSystem = resultValues[wellCellIndex]; double widthInFileUnitSystem = resultValues[wellCellIndex];
@ -436,7 +444,7 @@ FractureWidthAndConductivity RimStimPlanFractureTemplate::widthAndConductivityAt
if (widthInRequiredUnit != HUGE_VAL && fabs(widthInRequiredUnit) > 1e-20) if (widthInRequiredUnit != HUGE_VAL && fabs(widthInRequiredUnit) > 1e-20)
{ {
values.m_width = widthInRequiredUnit; values.m_width = widthInRequiredUnit;
values.m_permeability = conductivity / widthInRequiredUnit; values.m_permeability = conductivity / widthInRequiredUnit;
} }
} }
@ -452,7 +460,8 @@ std::pair<QString, QString> RimStimPlanFractureTemplate::widthParameterNameAndUn
{ {
if (m_stimPlanFractureDefinitionData.notNull()) if (m_stimPlanFractureDefinitionData.notNull())
{ {
std::vector<std::pair<QString, QString> > propertyNamesUnitsOnFile = m_stimPlanFractureDefinitionData->getStimPlanPropertyNamesUnits(); std::vector<std::pair<QString, QString>> propertyNamesUnitsOnFile =
m_stimPlanFractureDefinitionData->getStimPlanPropertyNamesUnits();
for (const auto& nameUnit : propertyNamesUnitsOnFile) for (const auto& nameUnit : propertyNamesUnitsOnFile)
{ {
@ -536,11 +545,15 @@ void RimStimPlanFractureTemplate::convertToUnitSystem(RiaEclipseUnitTools::UnitS
m_wellPathDepthAtFracture = RiaEclipseUnitTools::feetToMeter(m_wellPathDepthAtFracture); m_wellPathDepthAtFracture = RiaEclipseUnitTools::feetToMeter(m_wellPathDepthAtFracture);
} }
m_activeTimeStepIndex = static_cast<int>(m_stimPlanFractureDefinitionData->totalNumberTimeSteps() - 1); m_activeTimeStepIndex = static_cast<int>(m_stimPlanFractureDefinitionData->totalNumberTimeSteps() - 1);
bool polygonPropertySet = setBorderPolygonResultNameToDefault(); bool polygonPropertySet = setBorderPolygonResultNameToDefault();
if (polygonPropertySet) RiaLogging::info(QString("Calculating polygon outline based on %1 at timestep %2").arg(m_borderPolygonResultName).arg(m_stimPlanFractureDefinitionData->timeSteps()[m_activeTimeStepIndex])); if (polygonPropertySet)
else RiaLogging::info(QString("Property for polygon calculation not set.")); RiaLogging::info(QString("Calculating polygon outline based on %1 at timestep %2")
.arg(m_borderPolygonResultName)
.arg(m_stimPlanFractureDefinitionData->timeSteps()[m_activeTimeStepIndex]));
else
RiaLogging::info(QString("Property for polygon calculation not set."));
if (!m_stimPlanFractureDefinitionData->conductivityResultNames().isEmpty()) if (!m_stimPlanFractureDefinitionData->conductivityResultNames().isEmpty())
{ {
@ -561,7 +574,6 @@ void RimStimPlanFractureTemplate::reload()
{ {
proj->createDisplayModelAndRedrawAllViews(); proj->createDisplayModelAndRedrawAllViews();
} }
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -580,17 +592,18 @@ std::vector<double> RimStimPlanFractureTemplate::timeSteps()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<std::pair<QString, QString> > RimStimPlanFractureTemplate::uiResultNamesWithUnit() const std::vector<std::pair<QString, QString>> RimStimPlanFractureTemplate::uiResultNamesWithUnit() const
{ {
std::vector<std::pair<QString, QString> > propertyNamesAndUnits; std::vector<std::pair<QString, QString>> propertyNamesAndUnits;
if (m_stimPlanFractureDefinitionData.notNull()) if (m_stimPlanFractureDefinitionData.notNull())
{ {
QString conductivityUnit = "mD/s"; QString conductivityUnit = "mD/s";
std::vector<std::pair<QString, QString> > tmp; std::vector<std::pair<QString, QString>> tmp;
std::vector<std::pair<QString, QString> > propertyNamesUnitsOnFile = m_stimPlanFractureDefinitionData->getStimPlanPropertyNamesUnits(); std::vector<std::pair<QString, QString>> propertyNamesUnitsOnFile =
m_stimPlanFractureDefinitionData->getStimPlanPropertyNamesUnits();
for (const auto& nameUnitPair : propertyNamesUnitsOnFile) for (const auto& nameUnitPair : propertyNamesUnitsOnFile)
{ {
if (nameUnitPair.first.contains(RiaDefines::conductivityResultName(), Qt::CaseInsensitive)) if (nameUnitPair.first.contains(RiaDefines::conductivityResultName(), Qt::CaseInsensitive))
@ -617,7 +630,8 @@ std::vector<std::pair<QString, QString> > RimStimPlanFractureTemplate::uiResultN
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<std::vector<double>> RimStimPlanFractureTemplate::resultValues(const QString& uiResultName, const QString& unitName, size_t timeStepIndex) const std::vector<std::vector<double>>
RimStimPlanFractureTemplate::resultValues(const QString& uiResultName, const QString& unitName, size_t timeStepIndex) const
{ {
if (m_stimPlanFractureDefinitionData.notNull()) if (m_stimPlanFractureDefinitionData.notNull())
{ {
@ -632,7 +646,9 @@ std::vector<std::vector<double>> RimStimPlanFractureTemplate::resultValues(const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::vector<double> RimStimPlanFractureTemplate::fractureGridResults(const QString& uiResultName, const QString& unitName, size_t timeStepIndex) const std::vector<double> RimStimPlanFractureTemplate::fractureGridResults(const QString& uiResultName,
const QString& unitName,
size_t timeStepIndex) const
{ {
if (m_stimPlanFractureDefinitionData.notNull()) if (m_stimPlanFractureDefinitionData.notNull())
{ {
@ -641,7 +657,7 @@ std::vector<double> RimStimPlanFractureTemplate::fractureGridResults(const QStri
return m_stimPlanFractureDefinitionData->fractureGridResults(fileResultName, unitName, timeStepIndex); return m_stimPlanFractureDefinitionData->fractureGridResults(fileResultName, unitName, timeStepIndex);
} }
return std::vector<double>(); return std::vector<double>();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -649,8 +665,7 @@ std::vector<double> RimStimPlanFractureTemplate::fractureGridResults(const QStri
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimStimPlanFractureTemplate::hasConductivity() const bool RimStimPlanFractureTemplate::hasConductivity() const
{ {
if (m_stimPlanFractureDefinitionData.notNull() && if (m_stimPlanFractureDefinitionData.notNull() && !m_stimPlanFractureDefinitionData->conductivityResultNames().isEmpty())
!m_stimPlanFractureDefinitionData->conductivityResultNames().isEmpty())
{ {
return true; return true;
} }
@ -661,7 +676,11 @@ bool RimStimPlanFractureTemplate::hasConductivity() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RimStimPlanFractureTemplate::resultValueAtIJ(const QString& uiResultName, const QString& unitName, size_t timeStepIndex, size_t i, size_t j) double RimStimPlanFractureTemplate::resultValueAtIJ(const QString& uiResultName,
const QString& unitName,
size_t timeStepIndex,
size_t i,
size_t j)
{ {
auto values = resultValues(uiResultName, unitName, timeStepIndex); auto values = resultValues(uiResultName, unitName, timeStepIndex);
@ -672,7 +691,6 @@ double RimStimPlanFractureTemplate::resultValueAtIJ(const QString& uiResultName,
if (adjustedI >= fractureGrid()->iCellCount() || adjustedJ >= fractureGrid()->jCellCount()) if (adjustedI >= fractureGrid()->iCellCount() || adjustedJ >= fractureGrid()->jCellCount())
{ {
return HUGE_VAL; return HUGE_VAL;
} }
@ -706,15 +724,17 @@ double RimStimPlanFractureTemplate::longestYRange() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimStimPlanFractureTemplate::appendDataToResultStatistics(const QString& uiResultName, const QString& unit, void RimStimPlanFractureTemplate::appendDataToResultStatistics(const QString& uiResultName,
MinMaxAccumulator& minMaxAccumulator, const QString& unit,
PosNegAccumulator& posNegAccumulator) const MinMaxAccumulator& minMaxAccumulator,
PosNegAccumulator& posNegAccumulator) const
{ {
if (m_stimPlanFractureDefinitionData.notNull()) if (m_stimPlanFractureDefinitionData.notNull())
{ {
QString fileResultName = mapUiResultNameToFileResultName(uiResultName); QString fileResultName = mapUiResultNameToFileResultName(uiResultName);
m_stimPlanFractureDefinitionData->appendDataToResultStatistics(fileResultName, unit, minMaxAccumulator, posNegAccumulator); m_stimPlanFractureDefinitionData->appendDataToResultStatistics(
fileResultName, unit, minMaxAccumulator, posNegAccumulator);
} }
} }
@ -731,17 +751,15 @@ const RigFractureGrid* RimStimPlanFractureTemplate::fractureGrid() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimStimPlanFractureTemplate::updateFractureGrid() void RimStimPlanFractureTemplate::updateFractureGrid()
{ {
m_fractureGrid = nullptr; m_fractureGrid = nullptr;
m_areaWeightedConductivity = 0.0; m_areaWeightedConductivity = 0.0;
m_areaWeightedWidth = 0.0; m_areaWeightedWidth = 0.0;
m_longestYRangeAboveConductivityThreshold = 0.0; m_longestYRangeAboveConductivityThreshold = 0.0;
if (m_stimPlanFractureDefinitionData.notNull()) if (m_stimPlanFractureDefinitionData.notNull())
{ {
m_fractureGrid = m_stimPlanFractureDefinitionData->createFractureGrid(m_conductivityResultNameOnFile, m_fractureGrid = m_stimPlanFractureDefinitionData->createFractureGrid(
m_activeTimeStepIndex, m_conductivityResultNameOnFile, m_activeTimeStepIndex, m_wellPathDepthAtFracture, m_fractureTemplateUnit());
m_wellPathDepthAtFracture,
m_fractureTemplateUnit());
if (m_fractureGrid.notNull()) if (m_fractureGrid.notNull())
{ {
std::vector<double> areaPerCell; std::vector<double> areaPerCell;
@ -788,8 +806,8 @@ void RimStimPlanFractureTemplate::updateFractureGrid()
double currentYRange = 0.0; double currentYRange = 0.0;
for (size_t j = 0; j < m_fractureGrid->jCellCount(); j++) for (size_t j = 0; j < m_fractureGrid->jCellCount(); j++)
{ {
size_t globalIndex = m_fractureGrid->getGlobalIndexFromIJ(i, j); size_t globalIndex = m_fractureGrid->getGlobalIndexFromIJ(i, j);
const auto& cell = m_fractureGrid->cellFromIndex(globalIndex); const auto& cell = m_fractureGrid->cellFromIndex(globalIndex);
if (cell.hasNonZeroConductivity()) if (cell.hasNonZeroConductivity())
{ {
currentYRange += cell.cellSizeZ(); currentYRange += cell.cellSizeZ();
@ -814,14 +832,12 @@ void RimStimPlanFractureTemplate::updateFractureGrid()
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimStimPlanFractureTemplate::fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords, void RimStimPlanFractureTemplate::fractureTriangleGeometry(std::vector<cvf::Vec3f>* nodeCoords,
std::vector<cvf::uint>* triangleIndices) const std::vector<cvf::uint>* triangleIndices) const
{ {
if (m_stimPlanFractureDefinitionData.notNull()) if (m_stimPlanFractureDefinitionData.notNull())
{ {
m_stimPlanFractureDefinitionData->createFractureTriangleGeometry(m_wellPathDepthAtFracture, m_stimPlanFractureDefinitionData->createFractureTriangleGeometry(
name(), m_wellPathDepthAtFracture, name(), nodeCoords, triangleIndices);
nodeCoords,
triangleIndices);
} }
} }
@ -859,7 +875,9 @@ void RimStimPlanFractureTemplate::defineUiOrdering(QString uiConfigName, caf::Pd
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimStimPlanFractureTemplate::defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute * attribute) void RimStimPlanFractureTemplate::defineEditorAttribute(const caf::PdmFieldHandle* field,
QString uiConfigName,
caf::PdmUiEditorAttribute* attribute)
{ {
RimFractureTemplate::defineEditorAttribute(field, uiConfigName, attribute); RimFractureTemplate::defineEditorAttribute(field, uiConfigName, attribute);
@ -874,10 +892,10 @@ void RimStimPlanFractureTemplate::defineEditorAttribute(const caf::PdmFieldHandl
if (field == &m_wellPathDepthAtFracture) if (field == &m_wellPathDepthAtFracture)
{ {
if ( !m_stimPlanFractureDefinitionData.isNull() && (m_stimPlanFractureDefinitionData->yCount() > 0) ) if (!m_stimPlanFractureDefinitionData.isNull() && (m_stimPlanFractureDefinitionData->yCount() > 0))
{ {
caf::PdmUiDoubleSliderEditorAttribute* myAttr = dynamic_cast<caf::PdmUiDoubleSliderEditorAttribute*>(attribute); caf::PdmUiDoubleSliderEditorAttribute* myAttr = dynamic_cast<caf::PdmUiDoubleSliderEditorAttribute*>(attribute);
if ( myAttr ) if (myAttr)
{ {
myAttr->m_minimum = m_stimPlanFractureDefinitionData->minDepth(); myAttr->m_minimum = m_stimPlanFractureDefinitionData->minDepth();
myAttr->m_maximum = m_stimPlanFractureDefinitionData->maxDepth(); myAttr->m_maximum = m_stimPlanFractureDefinitionData->maxDepth();