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

#1585 Privatize data members in FractureDefinition

Browse Source
This commit is contained in:
Jacob Støren 2017-06-14 09:20:15 +02:00
parent a8b8e061d7
commit f87a186648
5 changed files with 70 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
ApplicationCode/FileInterface/RifStimPlanXmlReader.cpp
View File

@ -57,11 +57,11 @@ cvf::ref<RigStimPlanFractureDefinition> RifStimPlanXmlReader::readStimPlanXMLFil
}
size_t numberOfDepthValues = stimPlanFileData->depths.size();
RiaLogging::debug(QString("Grid size X: %1, Y: %2").arg(QString::number(stimPlanFileData->gridXs.size()),
size_t numberOfDepthValues = stimPlanFileData->depthCount();
RiaLogging::debug(QString("Grid size X: %1, Y: %2").arg(QString::number(stimPlanFileData->gridXCount()),
QString::number(numberOfDepthValues)));
size_t numberOfTimeSteps = stimPlanFileData->timeSteps.size();
size_t numberOfTimeSteps = stimPlanFileData->timeSteps().size();
RiaLogging::debug(QString("Number of time-steps: %1").arg(numberOfTimeSteps));
//Start reading from top:
@ -96,12 +96,12 @@ cvf::ref<RigStimPlanFractureDefinition> RifStimPlanXmlReader::readStimPlanXMLFil
{
if (unit == "md-ft")
{
stimPlanFileData->unitSet = RiaEclipseUnitTools::UNITS_FIELD;
stimPlanFileData->setUnitSet(RiaEclipseUnitTools::UNITS_FIELD);
RiaLogging::info(QString("Setting unit system to Field for StimPlan fracture template %1").arg(stimPlanFileName));
}
if (unit == "md-m")
{
stimPlanFileData->unitSet = RiaEclipseUnitTools::UNITS_METRIC;
stimPlanFileData->setUnitSet(RiaEclipseUnitTools::UNITS_METRIC);
RiaLogging::info(QString("Setting unit system to Metric for StimPlan fracture template %1").arg(stimPlanFileName));
}
}
@ -171,14 +171,14 @@ size_t RifStimPlanXmlReader::readStimplanGridAndTimesteps(QXmlStreamReader &xmlS
{
std::vector<double> gridValues;
getGriddingValues(xmlStream, gridValues, startNegValuesXs);
stimPlanFileData->gridXs = gridValues;
stimPlanFileData->setGridXs(gridValues);
}
else if (xmlStream.name() == "ys")
{
std::vector<double> gridValues;
getGriddingValues(xmlStream, gridValues, startNegValuesYs);
stimPlanFileData->gridYs = gridValues;
stimPlanFileData->setGridYs(gridValues);
stimPlanFileData->reorderYgridToDepths();
}
@ -186,10 +186,7 @@ size_t RifStimPlanXmlReader::readStimplanGridAndTimesteps(QXmlStreamReader &xmlS
else if (xmlStream.name() == "time")
{
double timeStepValue = getAttributeValueDouble(xmlStream, "value");
if (!stimPlanFileData->timeStepExisist(timeStepValue))
{
stimPlanFileData->timeSteps.push_back(timeStepValue);
}
stimPlanFileData->addTimeStep(timeStepValue);
}
}
}

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

@ -188,7 +188,7 @@ void RimStimPlanFractureTemplate::setDefaultsBasedOnXMLfile()
m_activeTimeStepIndex = static_cast<int>(m_stimPlanFractureDefinitionData->totalNumberTimeSteps() - 1);
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) 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."));
}
@ -229,7 +229,7 @@ void RimStimPlanFractureTemplate::loadDataAndUpdate()
if (m_stimPlanFractureDefinitionData.notNull())
{
fractureTemplateUnit = m_stimPlanFractureDefinitionData->unitSet;
fractureTemplateUnit = m_stimPlanFractureDefinitionData->unitSet();
}
else
{
@ -284,8 +284,8 @@ void RimStimPlanFractureTemplate::setDepthOfWellPathAtFracture()
{
if (!m_stimPlanFractureDefinitionData.isNull())
{
double firstDepth = m_stimPlanFractureDefinitionData->depths[0];
double lastDepth = m_stimPlanFractureDefinitionData->depths[m_stimPlanFractureDefinitionData->depths.size()-1];
double firstDepth = m_stimPlanFractureDefinitionData->minDepth();
double lastDepth = m_stimPlanFractureDefinitionData->maxDepth();
double averageDepth = (firstDepth + lastDepth) / 2;
m_wellPathDepthAtFracture = averageDepth;
}
@ -319,10 +319,10 @@ QString RimStimPlanFractureTemplate::getUnitForStimPlanParameter(QString paramet
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> RimStimPlanFractureTemplate::timeSteps()
const std::vector<double>& RimStimPlanFractureTemplate::timeSteps()
{
if (m_stimPlanFractureDefinitionData.isNull()) loadDataAndUpdate();
return m_stimPlanFractureDefinitionData->timeSteps;
return m_stimPlanFractureDefinitionData->timeSteps();
}
//--------------------------------------------------------------------------------------------------
@ -475,15 +475,14 @@ void RimStimPlanFractureTemplate::defineEditorAttribute(const caf::PdmFieldHandl
if (field == &m_wellPathDepthAtFracture)
{
if (!m_stimPlanFractureDefinitionData.isNull() && (m_stimPlanFractureDefinitionData->depths.size()>0))
if ( !m_stimPlanFractureDefinitionData.isNull() && (m_stimPlanFractureDefinitionData->depthCount() > 0) )
{
caf::PdmUiDoubleSliderEditorAttribute* myAttr = dynamic_cast<caf::PdmUiDoubleSliderEditorAttribute*>(attribute);
if (myAttr)
{
myAttr->m_minimum = m_stimPlanFractureDefinitionData->depths[0];
myAttr->m_maximum = m_stimPlanFractureDefinitionData->depths[m_stimPlanFractureDefinitionData->depths.size() - 1];
}
caf::PdmUiDoubleSliderEditorAttribute* myAttr = dynamic_cast<caf::PdmUiDoubleSliderEditorAttribute*>(attribute);
if ( myAttr )
{
myAttr->m_minimum = m_stimPlanFractureDefinitionData->minDepth();
myAttr->m_maximum = m_stimPlanFractureDefinitionData->maxDepth();
}
}
}
}

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

@ -73,7 +73,7 @@ public:
// Result Access
std::vector<double> timeSteps();
const std::vector<double>& timeSteps();
std::vector<std::pair<QString, QString> > resultNamesWithUnit() const;
void computeMinMax(const QString& resultName, const QString& unitName, double* minValue, double* maxValue) const;
std::vector<std::vector<double>> resultValues(const QString& resultName, const QString& unitName, size_t timeStepIndex) const;

51
ApplicationCode/ReservoirDataModel/RigStimPlanFractureDefinition.cpp
View File

@ -38,7 +38,7 @@ RigStimPlanResultFrames::RigStimPlanResultFrames()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigStimPlanFractureDefinition::RigStimPlanFractureDefinition() : unitSet(RiaEclipseUnitTools::UNITS_UNKNOWN)
RigStimPlanFractureDefinition::RigStimPlanFractureDefinition() : m_unitSet(RiaEclipseUnitTools::UNITS_UNKNOWN)
{
}
@ -57,7 +57,7 @@ RigStimPlanFractureDefinition::~RigStimPlanFractureDefinition()
std::vector<double> RigStimPlanFractureDefinition::getNegAndPosXcoords() const
{
std::vector<double> allXcoords;
for ( const double& xCoord : gridXs )
for ( const double& xCoord : m_gridXs )
{
if ( xCoord > 1e-5 )
{
@ -65,7 +65,7 @@ std::vector<double> RigStimPlanFractureDefinition::getNegAndPosXcoords() const
allXcoords.insert(allXcoords.begin(), negXcoord);
}
}
for ( const double& xCoord : gridXs )
for ( const double& xCoord : m_gridXs )
{
allXcoords.push_back(xCoord);
}
@ -79,7 +79,7 @@ std::vector<double> RigStimPlanFractureDefinition::getNegAndPosXcoords() const
bool RigStimPlanFractureDefinition::numberOfParameterValuesOK(std::vector<std::vector<double>> propertyValuesAtTimestep)
{
size_t depths = this->depths.size();
size_t gridXvalues = this->gridXs.size();
size_t gridXvalues = this->m_gridXs.size();
if ( propertyValuesAtTimestep.size() != depths ) return false;
for ( std::vector<double> valuesAtDepthVector : propertyValuesAtTimestep )
@ -113,8 +113,7 @@ std::vector<std::pair<QString, QString> > RigStimPlanFractureDefinition::getStim
{
std::vector<std::pair<QString, QString> > propertyNamesUnits;
{
std::vector<RigStimPlanResultFrames > allStimPlanData = this->m_stimPlanResults;
for ( RigStimPlanResultFrames stimPlanDataEntry : allStimPlanData )
for ( const RigStimPlanResultFrames& stimPlanDataEntry : this->m_stimPlanResults )
{
propertyNamesUnits.push_back(std::make_pair(stimPlanDataEntry.resultName, stimPlanDataEntry.unit));
}
@ -237,18 +236,18 @@ void RigStimPlanFractureDefinition::createFractureTriangleGeometry(double m_well
std::vector<double> adjustedDepths = this->adjustedDepthCoordsAroundWellPathPosition(m_wellPathDepthAtFracture);
if ( neededUnit == unitSet )
if ( neededUnit == m_unitSet )
{
RiaLogging::debug(QString("No conversion necessary for %1").arg(fractureUserName));
}
else if ( unitSet == RiaEclipseUnitTools::UNITS_METRIC && neededUnit == RiaEclipseUnitTools::UNITS_FIELD )
else if ( m_unitSet == RiaEclipseUnitTools::UNITS_METRIC && neededUnit == RiaEclipseUnitTools::UNITS_FIELD )
{
RiaLogging::info(QString("Converting StimPlan geometry from metric to field for fracture template %1").arg(fractureUserName));
for ( double& value : adjustedDepths ) value = RiaEclipseUnitTools::meterToFeet(value);
for ( double& value : xCoords ) value = RiaEclipseUnitTools::meterToFeet(value);
}
else if ( unitSet == RiaEclipseUnitTools::UNITS_FIELD && neededUnit == RiaEclipseUnitTools::UNITS_METRIC )
else if ( m_unitSet == RiaEclipseUnitTools::UNITS_FIELD && neededUnit == RiaEclipseUnitTools::UNITS_METRIC )
{
RiaLogging::info(QString("Converting StimPlan geometry from field to metric for fracture template %1").arg(fractureUserName));
for ( double& value : adjustedDepths ) value = RiaEclipseUnitTools::feetToMeter(value);
@ -348,17 +347,17 @@ std::vector<cvf::Vec3f> RigStimPlanFractureDefinition::createFractureBorderPolyg
{
if ( (i > 0) && ((dataAtTimeStep[k])[(i - 1)] > 1e-7) ) //side neighbour cell different from 0
{
polygon.push_back(cvf::Vec3f(static_cast<float>(this->gridXs[i]),
polygon.push_back(cvf::Vec3f(static_cast<float>(this->m_gridXs[i]),
static_cast<float>(adjustedDepths[k]), 0.0f));
}
else if ( (k < dataAtTimeStep.size() - 1) && ((dataAtTimeStep[k + 1])[(i)] > 1e-7) )//cell below different from 0
{
polygon.push_back(cvf::Vec3f(static_cast<float>(this->gridXs[i]),
polygon.push_back(cvf::Vec3f(static_cast<float>(this->m_gridXs[i]),
static_cast<float>(adjustedDepths[k]), 0.0f));
}
else if ( (k > 0) && ((dataAtTimeStep[k - 1])[(i)] > 1e-7) )//cell above different from 0
{
polygon.push_back(cvf::Vec3f(static_cast<float>(this->gridXs[i]),
polygon.push_back(cvf::Vec3f(static_cast<float>(this->m_gridXs[i]),
static_cast<float>(adjustedDepths[k]), 0.0f));
}
}
@ -384,12 +383,12 @@ std::vector<cvf::Vec3f> RigStimPlanFractureDefinition::createFractureBorderPolyg
if ( polygon.size()>0 ) polygon.push_back(polygon[0]);
if ( neededUnit == unitSet )
if ( neededUnit == m_unitSet )
{
RiaLogging::debug(QString("No conversion necessary for %1").arg(fractureUserName));
}
else if ( unitSet == RiaEclipseUnitTools::UNITS_METRIC && neededUnit == RiaEclipseUnitTools::UNITS_FIELD )
else if ( m_unitSet == RiaEclipseUnitTools::UNITS_METRIC && neededUnit == RiaEclipseUnitTools::UNITS_FIELD )
{
RiaLogging::info(QString("Converting StimPlan geometry from metric to field for fracture template %1").arg(fractureUserName));
for ( cvf::Vec3f& node : polygon )
@ -400,7 +399,7 @@ std::vector<cvf::Vec3f> RigStimPlanFractureDefinition::createFractureBorderPolyg
node = cvf::Vec3f(x, y, z);
}
}
else if ( unitSet == RiaEclipseUnitTools::UNITS_FIELD && neededUnit == RiaEclipseUnitTools::UNITS_METRIC )
else if ( m_unitSet == RiaEclipseUnitTools::UNITS_FIELD && neededUnit == RiaEclipseUnitTools::UNITS_METRIC )
{
RiaLogging::info(QString("Converting StimPlan geometry from field to metric for fracture template %1").arg(fractureUserName));
for ( cvf::Vec3f& node : polygon )
@ -426,7 +425,7 @@ std::vector<cvf::Vec3f> RigStimPlanFractureDefinition::createFractureBorderPolyg
//--------------------------------------------------------------------------------------------------
bool RigStimPlanFractureDefinition::timeStepExisist(double timeStepValueToCheck)
{
for (double timeStep : timeSteps)
for (double timeStep : m_timeSteps)
{
if (abs(timeStepValueToCheck - timeStep) < 1e-5) return true;
}
@ -439,7 +438,7 @@ bool RigStimPlanFractureDefinition::timeStepExisist(double timeStepValueToCheck)
void RigStimPlanFractureDefinition::reorderYgridToDepths()
{
std::vector<double> depthsInIncreasingOrder;
for (double gridYvalue : gridYs)
for (double gridYvalue : m_gridYs)
{
depthsInIncreasingOrder.insert(depthsInIncreasingOrder.begin(), gridYvalue);
}
@ -452,9 +451,9 @@ void RigStimPlanFractureDefinition::reorderYgridToDepths()
size_t RigStimPlanFractureDefinition::getTimeStepIndex(double timeStepValue)
{
size_t index = 0;
while (index < timeSteps.size())
while (index < m_timeSteps.size())
{
if (abs(timeSteps[index] - timeStepValue) < 1e-4)
if (abs(m_timeSteps[index] - timeStepValue) < 1e-4)
{
return index;
}
@ -468,7 +467,7 @@ size_t RigStimPlanFractureDefinition::getTimeStepIndex(double timeStepValue)
//--------------------------------------------------------------------------------------------------
size_t RigStimPlanFractureDefinition::totalNumberTimeSteps()
{
return timeSteps.size();
return m_timeSteps.size();
}
//--------------------------------------------------------------------------------------------------
@ -506,7 +505,7 @@ void RigStimPlanFractureDefinition::setDataAtTimeValue(QString resultName, QStri
resultData.resultName = resultName;
resultData.unit = unit;
std::vector<std::vector<std::vector<double>>> values(timeSteps.size());
std::vector<std::vector<std::vector<double>>> values(m_timeSteps.size());
resultData.parameterValues = values;
resultData.parameterValues[getTimeStepIndex(timeStepValue)] = data;
@ -517,7 +516,7 @@ void RigStimPlanFractureDefinition::setDataAtTimeValue(QString resultName, QStri
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::vector<double>> RigStimPlanFractureDefinition::getDataAtTimeIndex(const QString& resultName, const QString& unit, size_t timeStepIndex) const
const std::vector<std::vector<double>>& RigStimPlanFractureDefinition::getDataAtTimeIndex(const QString& resultName, const QString& unit, size_t timeStepIndex) const
{
size_t resIndex = resultIndex(resultName, unit);
@ -530,7 +529,7 @@ std::vector<std::vector<double>> RigStimPlanFractureDefinition::getDataAtTimeInd
}
qDebug() << "ERROR: Requested parameter does not exists in stimPlan data";
std::vector<std::vector<double>> emptyVector;
static std::vector<std::vector<double>> emptyVector;
return emptyVector;
}
@ -544,11 +543,11 @@ void RigStimPlanFractureDefinition::computeMinMax(const QString& resultName, con
size_t resIndex = resultIndex(resultName, unit);
if (resIndex == cvf::UNDEFINED_SIZE_T) return;
for (auto timeValues : m_stimPlanResults[resIndex].parameterValues)
for (const auto& timeValues : m_stimPlanResults[resIndex].parameterValues)
{
for (auto values : timeValues)
for (const auto& values : timeValues)
{
for (auto resultValue : values)
for (double resultValue : values)
{
if (resultValue < *minValue)
{

31
ApplicationCode/ReservoirDataModel/RigStimPlanFractureDefinition.h
View File

@ -47,16 +47,22 @@ public:
RigStimPlanFractureDefinition();
~RigStimPlanFractureDefinition();
RiaEclipseUnitTools::UnitSystem unitSet;
std::vector<double> gridXs;
RiaEclipseUnitTools::UnitSystem unitSet() { return m_unitSet; }
void setUnitSet(RiaEclipseUnitTools::UnitSystem unitset) { m_unitSet = unitset;}
size_t gridXCount() { return m_gridXs.size();}
void setGridXs(const std::vector<double>& gridXs) { m_gridXs = gridXs; }
//TODO: Consider removing gridYs or depths,
//In example file these are the same, but can there be examples where not all gridY values are included in depths?
void setGridYs(const std::vector<double>& gridYs) { m_gridYs = gridYs; }
std::vector<double> gridYs;
std::vector<double> depths;
double minDepth() { return depths[0]; }
double maxDepth() { return depths.back(); }
size_t depthCount() { return depths.size(); }
std::vector<double> timeSteps;
// Grid Geometry
@ -86,21 +92,30 @@ public:
RiaEclipseUnitTools::UnitSystem neededUnit,
const QString& fractureUserName);
// Result Access
const std::vector<double>& timeSteps() const { return m_timeSteps; }
void addTimeStep(double time) { if (!timeStepExisist(time)) m_timeSteps.push_back(time); }
std::vector<std::pair<QString, QString> > getStimPlanPropertyNamesUnits() const;
bool numberOfParameterValuesOK(std::vector<std::vector<double>> propertyValuesAtTimestep);
bool timeStepExisist(double timeStepValue);
size_t totalNumberTimeSteps();
void setDataAtTimeValue(QString resultName, QString unit, std::vector<std::vector<double>> data, double timeStepValue);
std::vector<std::vector<double>> getDataAtTimeIndex(const QString& resultName, const QString& unit, size_t timeStepIndex) const;
const std::vector<std::vector<double>>& getDataAtTimeIndex(const QString& resultName, const QString& unit, size_t timeStepIndex) const;
void computeMinMax(const QString& resultName, const QString& unit, double* minValue, double* maxValue) const;
// Setup
void reorderYgridToDepths();
private:
bool timeStepExisist(double timeStepValue);
size_t getTimeStepIndex(double timeStepValue);
size_t resultIndex(const QString& resultName, const QString& unit) const;
RiaEclipseUnitTools::UnitSystem m_unitSet;
std::vector<double> m_gridXs;
std::vector<double> m_gridYs;
std::vector<double> depths;
std::vector<double> m_timeSteps;
std::vector<RigStimPlanResultFrames> m_stimPlanResults;
};