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

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

@ -188,7 +188,7 @@ 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) 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.")); else RiaLogging::info(QString("Property for polygon calculation not set."));
} }
@ -229,7 +229,7 @@ void RimStimPlanFractureTemplate::loadDataAndUpdate()
if (m_stimPlanFractureDefinitionData.notNull()) if (m_stimPlanFractureDefinitionData.notNull())
{ {
fractureTemplateUnit = m_stimPlanFractureDefinitionData->unitSet; fractureTemplateUnit = m_stimPlanFractureDefinitionData->unitSet();
} }
else else
{ {
@ -284,8 +284,8 @@ void RimStimPlanFractureTemplate::setDepthOfWellPathAtFracture()
{ {
if (!m_stimPlanFractureDefinitionData.isNull()) if (!m_stimPlanFractureDefinitionData.isNull())
{ {
double firstDepth = m_stimPlanFractureDefinitionData->depths[0]; double firstDepth = m_stimPlanFractureDefinitionData->minDepth();
double lastDepth = m_stimPlanFractureDefinitionData->depths[m_stimPlanFractureDefinitionData->depths.size()-1]; double lastDepth = m_stimPlanFractureDefinitionData->maxDepth();
double averageDepth = (firstDepth + lastDepth) / 2; double averageDepth = (firstDepth + lastDepth) / 2;
m_wellPathDepthAtFracture = averageDepth; 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(); 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 (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); caf::PdmUiDoubleSliderEditorAttribute* myAttr = dynamic_cast<caf::PdmUiDoubleSliderEditorAttribute*>(attribute);
if (myAttr) if ( myAttr )
{ {
myAttr->m_minimum = m_stimPlanFractureDefinitionData->depths[0]; myAttr->m_minimum = m_stimPlanFractureDefinitionData->minDepth();
myAttr->m_maximum = m_stimPlanFractureDefinitionData->depths[m_stimPlanFractureDefinitionData->depths.size() - 1]; myAttr->m_maximum = m_stimPlanFractureDefinitionData->maxDepth();
} }
} }
} }
} }

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

@ -73,7 +73,7 @@ public:
// Result Access // Result Access
std::vector<double> timeSteps(); const std::vector<double>& timeSteps();
std::vector<std::pair<QString, QString> > resultNamesWithUnit() const; std::vector<std::pair<QString, QString> > resultNamesWithUnit() const;
void computeMinMax(const QString& resultName, const QString& unitName, double* minValue, double* maxValue) 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; 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> RigStimPlanFractureDefinition::getNegAndPosXcoords() const
{ {
std::vector<double> allXcoords; std::vector<double> allXcoords;
for ( const double& xCoord : gridXs ) for ( const double& xCoord : m_gridXs )
{ {
if ( xCoord > 1e-5 ) if ( xCoord > 1e-5 )
{ {
@ -65,7 +65,7 @@ std::vector<double> RigStimPlanFractureDefinition::getNegAndPosXcoords() const
allXcoords.insert(allXcoords.begin(), negXcoord); allXcoords.insert(allXcoords.begin(), negXcoord);
} }
} }
for ( const double& xCoord : gridXs ) for ( const double& xCoord : m_gridXs )
{ {
allXcoords.push_back(xCoord); allXcoords.push_back(xCoord);
} }
@ -79,7 +79,7 @@ std::vector<double> RigStimPlanFractureDefinition::getNegAndPosXcoords() const
bool RigStimPlanFractureDefinition::numberOfParameterValuesOK(std::vector<std::vector<double>> propertyValuesAtTimestep) bool RigStimPlanFractureDefinition::numberOfParameterValuesOK(std::vector<std::vector<double>> propertyValuesAtTimestep)
{ {
size_t depths = this->depths.size(); 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; if ( propertyValuesAtTimestep.size() != depths ) return false;
for ( std::vector<double> valuesAtDepthVector : propertyValuesAtTimestep ) 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<std::pair<QString, QString> > propertyNamesUnits;
{ {
std::vector<RigStimPlanResultFrames > allStimPlanData = this->m_stimPlanResults; for ( const RigStimPlanResultFrames& stimPlanDataEntry : this->m_stimPlanResults )
for ( RigStimPlanResultFrames stimPlanDataEntry : allStimPlanData )
{ {
propertyNamesUnits.push_back(std::make_pair(stimPlanDataEntry.resultName, stimPlanDataEntry.unit)); 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); 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)); 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)); 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 : adjustedDepths ) value = RiaEclipseUnitTools::meterToFeet(value);
for ( double& value : xCoords ) 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)); RiaLogging::info(QString("Converting StimPlan geometry from field to metric for fracture template %1").arg(fractureUserName));
for ( double& value : adjustedDepths ) value = RiaEclipseUnitTools::feetToMeter(value); 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 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)); static_cast<float>(adjustedDepths[k]), 0.0f));
} }
else if ( (k < dataAtTimeStep.size() - 1) && ((dataAtTimeStep[k + 1])[(i)] > 1e-7) )//cell below different from 0 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)); static_cast<float>(adjustedDepths[k]), 0.0f));
} }
else if ( (k > 0) && ((dataAtTimeStep[k - 1])[(i)] > 1e-7) )//cell above different from 0 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)); 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 ( 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)); 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)); RiaLogging::info(QString("Converting StimPlan geometry from metric to field for fracture template %1").arg(fractureUserName));
for ( cvf::Vec3f& node : polygon ) for ( cvf::Vec3f& node : polygon )
@ -400,7 +399,7 @@ std::vector<cvf::Vec3f> RigStimPlanFractureDefinition::createFractureBorderPolyg
node = cvf::Vec3f(x, y, z); 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)); RiaLogging::info(QString("Converting StimPlan geometry from field to metric for fracture template %1").arg(fractureUserName));
for ( cvf::Vec3f& node : polygon ) for ( cvf::Vec3f& node : polygon )
@ -426,7 +425,7 @@ std::vector<cvf::Vec3f> RigStimPlanFractureDefinition::createFractureBorderPolyg
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RigStimPlanFractureDefinition::timeStepExisist(double timeStepValueToCheck) bool RigStimPlanFractureDefinition::timeStepExisist(double timeStepValueToCheck)
{ {
for (double timeStep : timeSteps) for (double timeStep : m_timeSteps)
{ {
if (abs(timeStepValueToCheck - timeStep) < 1e-5) return true; if (abs(timeStepValueToCheck - timeStep) < 1e-5) return true;
} }
@ -439,7 +438,7 @@ bool RigStimPlanFractureDefinition::timeStepExisist(double timeStepValueToCheck)
void RigStimPlanFractureDefinition::reorderYgridToDepths() void RigStimPlanFractureDefinition::reorderYgridToDepths()
{ {
std::vector<double> depthsInIncreasingOrder; std::vector<double> depthsInIncreasingOrder;
for (double gridYvalue : gridYs) for (double gridYvalue : m_gridYs)
{ {
depthsInIncreasingOrder.insert(depthsInIncreasingOrder.begin(), gridYvalue); depthsInIncreasingOrder.insert(depthsInIncreasingOrder.begin(), gridYvalue);
} }
@ -452,9 +451,9 @@ void RigStimPlanFractureDefinition::reorderYgridToDepths()
size_t RigStimPlanFractureDefinition::getTimeStepIndex(double timeStepValue) size_t RigStimPlanFractureDefinition::getTimeStepIndex(double timeStepValue)
{ {
size_t index = 0; 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; return index;
} }
@ -468,7 +467,7 @@ size_t RigStimPlanFractureDefinition::getTimeStepIndex(double timeStepValue)
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
size_t RigStimPlanFractureDefinition::totalNumberTimeSteps() 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.resultName = resultName;
resultData.unit = unit; 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 = values;
resultData.parameterValues[getTimeStepIndex(timeStepValue)] = data; 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); 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"; 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; return emptyVector;
} }
@ -544,11 +543,11 @@ void RigStimPlanFractureDefinition::computeMinMax(const QString& resultName, con
size_t resIndex = resultIndex(resultName, unit); size_t resIndex = resultIndex(resultName, unit);
if (resIndex == cvf::UNDEFINED_SIZE_T) return; 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) if (resultValue < *minValue)
{ {

29
ApplicationCode/ReservoirDataModel/RigStimPlanFractureDefinition.h
View File

@ -47,16 +47,22 @@ public:
RigStimPlanFractureDefinition(); RigStimPlanFractureDefinition();
~RigStimPlanFractureDefinition(); ~RigStimPlanFractureDefinition();
RiaEclipseUnitTools::UnitSystem unitSet; RiaEclipseUnitTools::UnitSystem unitSet() { return m_unitSet; }
std::vector<double> gridXs; 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, //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? //In example file these are the same, but can there be examples where not all gridY values are included in depths?
std::vector<double> gridYs; void setGridYs(const std::vector<double>& gridYs) { m_gridYs = 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 // Grid Geometry
@ -87,20 +93,29 @@ public:
const QString& fractureUserName); const QString& fractureUserName);
// Result Access // 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; std::vector<std::pair<QString, QString> > getStimPlanPropertyNamesUnits() const;
bool numberOfParameterValuesOK(std::vector<std::vector<double>> propertyValuesAtTimestep); bool numberOfParameterValuesOK(std::vector<std::vector<double>> propertyValuesAtTimestep);
bool timeStepExisist(double timeStepValue);
size_t totalNumberTimeSteps(); size_t totalNumberTimeSteps();
void setDataAtTimeValue(QString resultName, QString unit, std::vector<std::vector<double>> data, double timeStepValue); 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; void computeMinMax(const QString& resultName, const QString& unit, double* minValue, double* maxValue) const;
// Setup // Setup
void reorderYgridToDepths(); void reorderYgridToDepths();
private: private:
bool timeStepExisist(double timeStepValue);
size_t getTimeStepIndex(double timeStepValue); size_t getTimeStepIndex(double timeStepValue);
size_t resultIndex(const QString& resultName, const QString& unit) const; 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; std::vector<RigStimPlanResultFrames> m_stimPlanResults;
}; };