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

Merge branch 'dev' into measurement

Browse Source
This commit is contained in:
Bjørn Erik Jensen
2018-12-21 10:08:41 +01:00
parent 21403f4161 b1b278fffc
commit 5976298267
76 changed files with 15220 additions and 474 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
ApplicationCode/ProjectDataModel/Completions/RimFishbonesMultipleSubs.cpp
View File

@@ -98,6 +98,7 @@ RimFishbonesMultipleSubs::RimFishbonesMultipleSubs()
initialiseObsoleteFields();
CAF_PDM_InitFieldNoDefault(&m_valveLocations, "ValveLocations", "Valve Locations", "", "", "");
m_valveLocations = new RimMultipleValveLocations();
m_valveLocations->findField("RangeValveCount")->uiCapability()->setUiName("Number of Subs");
m_valveLocations.uiCapability()->setUiHidden(true);
m_valveLocations.uiCapability()->setUiTreeChildrenHidden(true);

2
ApplicationCode/ProjectDataModel/Completions/RimMultipleValveLocations.cpp
View File

@@ -36,7 +36,7 @@ namespace caf {
template<>
void AppEnum<RimMultipleValveLocations::LocationType>::setUp()
{
addItem(RimMultipleValveLocations::VALVE_COUNT, "VALVE_COUNT", "Start/End/Number of Valves");
addItem(RimMultipleValveLocations::VALVE_COUNT, "VALVE_COUNT", "Start/End/Number");
addItem(RimMultipleValveLocations::VALVE_SPACING, "VALVE_SPACING", "Start/End/Spacing");
addItem(RimMultipleValveLocations::VALVE_CUSTOM, "VALVE_CUSTOM", "User Specification");
setDefault(RimMultipleValveLocations::VALVE_COUNT);

12
ApplicationCode/ProjectDataModel/Completions/RimWellPathCompletions.cpp
View File

@@ -237,6 +237,15 @@ void RimWellPathCompletions::setUnitSystemSpecificDefaults()
m_perforationCollection->setUnitSystemSpecificDefaults();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QRegExp RimWellPathCompletions::wellNameForExportRegExp()
{
QRegExp rx("[\\w\\-\\_]{1,8}");
return rx;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -295,9 +304,8 @@ void RimWellPathCompletions::defineEditorAttribute(const caf::PdmFieldHandle* fi
caf::PdmUiLineEditorAttribute* lineEditorAttr = dynamic_cast<caf::PdmUiLineEditorAttribute*>(attribute);
if (field == &m_wellNameForExport && lineEditorAttr)
{
QRegExp rx("[\\w\\-\\_]{1,8}");
QRegExpValidator* validator = new QRegExpValidator(nullptr);
validator->setRegExp(rx);
validator->setRegExp(wellNameForExportRegExp());
lineEditorAttr->validator = validator;
}
}

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

@@ -57,7 +57,7 @@ public:
bool hasCompletions() const;
void setUnitSystemSpecificDefaults();
static QRegExp wellNameForExportRegExp();
protected:
void defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName) override;
void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;

7
ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@@ -486,12 +486,16 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
{
menuBuilder << "RicPasteSummaryCurveFeature";
menuBuilder << "RicPasteSummaryCrossPlotCurveFeature";
menuBuilder << "Separator";
menuBuilder << "RicNewSummaryCurveFeature";
menuBuilder << "RicDuplicateSummaryCurveFeature";
menuBuilder << "RicNewSummaryCrossPlotCurveFeature";
menuBuilder << "RicDuplicateSummaryCrossPlotCurveFeature";
menuBuilder << "Separator";
menuBuilder << "RicSetSourceSteppingSummaryCurveFeature";
menuBuilder << "RicClearSourceSteppingSummaryCurveFeature";
menuBuilder << "Separator";
menuBuilder << "RicCopyReferencesToClipboardFeature";
menuBuilder << "Separator";
menuBuilder << "RicEditSummaryCurveCalculationFeature";
@@ -513,6 +517,9 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
else if (dynamic_cast<RimEnsembleCurveSet*>(uiItem))
{
menuBuilder << "RicNewSummaryEnsembleCurveSetFeature";
menuBuilder << "Separator";
menuBuilder << "RicSetSourceSteppingEnsembleCurveSetFeature";
menuBuilder << "RicClearSourceSteppingEnsembleCurveSetFeature";
}
else if (dynamic_cast<RimEnsembleCurveFilterCollection*>(uiItem))
{

86
ApplicationCode/ProjectDataModel/RimContourMapProjection.cpp
View File

@@ -24,6 +24,7 @@
#include "RimEclipseResultDefinition.h"
#include "RimProject.h"
#include "RimRegularLegendConfig.h"
#include "RimTextAnnotation.h"
#include "cafContourLines.h"
#include "cafPdmUiDoubleSliderEditor.h"
@@ -77,6 +78,7 @@ RimContourMapProjection::RimContourMapProjection()
CAF_PDM_InitFieldNoDefault(&m_resultAggregation, "ResultAggregation", "Result Aggregation", "", "", "");
CAF_PDM_InitField(&m_showContourLines, "ContourLines", true, "Show Contour Lines", "", "", "");
CAF_PDM_InitField(&m_showContourLabels, "ContourLabels", false, "Show Contour Labels", "", "", "");
CAF_PDM_InitField(&m_weightByParameter, "WeightByParameter", false, "Weight by Result Parameter", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_weightingResult, "WeightingResult", "", "", "", "");
@@ -84,6 +86,7 @@ RimContourMapProjection::RimContourMapProjection()
m_weightingResult.uiCapability()->setUiTreeChildrenHidden(true);
m_weightingResult = new RimEclipseResultDefinition;
m_weightingResult->findField("MResultType")->uiCapability()->setUiName("Result Type");
setName("Map Projection");
nameField()->uiCapability()->setUiReadOnly(true);
@@ -102,11 +105,10 @@ RimContourMapProjection::~RimContourMapProjection()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimContourMapProjection::generateVertices(cvf::Vec3fArray* vertices, const caf::DisplayCoordTransform* displayCoordTransform)
std::vector<cvf::Vec3d> RimContourMapProjection::generateVertices()
{
CVF_ASSERT(vertices);
size_t nVertices = numberOfVertices();
vertices->resize(nVertices);
std::vector<cvf::Vec3d> vertices(nVertices, cvf::Vec3d::ZERO);
#pragma omp parallel for
for (int index = 0; index < static_cast<int>(nVertices); ++index)
@@ -117,10 +119,10 @@ void RimContourMapProjection::generateVertices(cvf::Vec3fArray* vertices, const
globalPos.x() -= m_sampleSpacing * 0.5;
globalPos.y() -= m_sampleSpacing * 0.5;
cvf::Vec3d globalVertexPos(globalPos, m_fullBoundingBox.min().z() - 1.0);
cvf::Vec3f displayVertexPos(displayCoordTransform->transformToDisplayCoord(globalVertexPos));
(*vertices)[index] = displayVertexPos;
cvf::Vec3d globalVertexPos(globalPos, m_fullBoundingBox.min().z());
vertices[index] = globalVertexPos;
}
return vertices;
}
@@ -128,9 +130,10 @@ void RimContourMapProjection::generateVertices(cvf::Vec3fArray* vertices, const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimContourMapProjection::ContourPolygons RimContourMapProjection::generateContourPolygons(const caf::DisplayCoordTransform* displayCoordTransform)
void RimContourMapProjection::generateContourPolygons()
{
std::vector<cvf::ref<cvf::Vec3fArray>> contourPolygons;
std::vector<ContourPolygons> contourPolygons;
if (minValue() != std::numeric_limits<double>::infinity() &&
maxValue() != -std::numeric_limits<double>::infinity() &&
std::fabs(maxValue() - minValue()) > 1.0e-8)
@@ -142,49 +145,51 @@ RimContourMapProjection::ContourPolygons RimContourMapProjection::generateContou
int nContourLevels = static_cast<int>(contourLevels.size());
if (nContourLevels > 2)
{
std::vector<double> fudgedContourLevels = contourLevels;
if (legendConfig()->mappingMode() == RimRegularLegendConfig::LINEAR_CONTINUOUS || legendConfig()->mappingMode() == RimRegularLegendConfig::LINEAR_DISCRETE)
{
// Slight fudge to avoid very jagged contour lines at the very edge
// Shift the contour levels inwards.
contourLevels[0] += (contourLevels[1] - contourLevels[0]) * 0.1;
contourLevels[nContourLevels - 1] -= (contourLevels[nContourLevels - 1] - contourLevels[nContourLevels - 2]) * 0.1;
fudgedContourLevels[0] += (contourLevels[1] - contourLevels[0]) * 0.1;
fudgedContourLevels[nContourLevels - 1] -= (contourLevels[nContourLevels - 1] - contourLevels[nContourLevels - 2]) * 0.1;
}
std::vector<std::vector<cvf::Vec2d>> contourLines;
caf::ContourLines::create(m_aggregatedVertexResults, xVertexPositions(), yVertexPositions(), contourLevels, &contourLines);
std::vector<caf::ContourLines::ClosedPolygons> closedContourLines =
caf::ContourLines::create(m_aggregatedVertexResults, xVertexPositions(), yVertexPositions(), fudgedContourLevels);
contourPolygons.reserve(contourLines.size());
for (size_t i = 0; i < contourLines.size(); ++i)
contourPolygons.resize(closedContourLines.size());
for (size_t i = 0; i < closedContourLines.size(); ++i)
{
if (!contourLines[i].empty())
for (size_t j = 0; j < closedContourLines[i].size(); ++j)
{
cvf::ref<cvf::Vec3fArray> contourPolygon = new cvf::Vec3fArray(contourLines[i].size());
for (size_t j = 0; j < contourLines[i].size(); ++j)
ContourPolygon contourPolygon;
contourPolygon.label = cvf::String(contourLevels[i]);
contourPolygon.vertices.reserve(closedContourLines[i][j].size());
for (size_t k = 0; k < closedContourLines[i][j].size(); ++k)
{
cvf::Vec3d contourPoint3d = cvf::Vec3d(contourLines[i][j], m_fullBoundingBox.min().z());
cvf::Vec3d displayPoint3d = displayCoordTransform->transformToDisplayCoord(contourPoint3d);
(*contourPolygon)[j] = cvf::Vec3f(displayPoint3d);
cvf::Vec3d contourPoint3d = cvf::Vec3d(closedContourLines[i][j][k], m_fullBoundingBox.min().z());
contourPolygon.vertices.push_back(contourPoint3d);
}
contourPolygons.push_back(contourPolygon);
contourPolygons[i].push_back(contourPolygon);
}
}
}
}
}
return contourPolygons;
m_contourPolygons = contourPolygons;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::Vec3fArray>
RimContourMapProjection::generatePickPointPolygon(const caf::DisplayCoordTransform* displayCoordTransform)
std::vector<cvf::Vec3d>
RimContourMapProjection::generatePickPointPolygon()
{
cvf::ref<cvf::Vec3fArray> pickPolygon;
std::vector<cvf::Vec3d> points;
if (!m_pickPoint.isUndefined())
{
double zPos = m_fullBoundingBox.min().z();
std::vector<cvf::Vec3d> points;
{
cvf::Vec2d gridorigin(m_fullBoundingBox.min().x(), m_fullBoundingBox.min().y());
@@ -209,16 +214,8 @@ RimContourMapProjection::generatePickPointPolygon(const caf::DisplayCoordTransfo
points.push_back(cvf::Vec3d(m_pickPoint - cvf::Vec2d(0.0, 0.5 * m_sampleSpacing), zPos));
points.push_back(cvf::Vec3d(m_pickPoint + cvf::Vec2d(0.0, 0.5 * m_sampleSpacing), zPos));
}
pickPolygon = new cvf::Vec3fArray(points.size());
for (size_t i = 0; i < points.size(); ++i)
{
cvf::Vec3d displayPoint = displayCoordTransform->transformToDisplayCoord(points[i]);
(*pickPolygon)[i] = cvf::Vec3f(displayPoint);
}
}
return pickPolygon;
return points;
}
//--------------------------------------------------------------------------------------------------
@@ -285,6 +282,14 @@ void RimContourMapProjection::generateResults()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<RimContourMapProjection::ContourPolygons>& RimContourMapProjection::contourPolygons() const
{
return m_contourPolygons;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -317,6 +322,14 @@ bool RimContourMapProjection::showContourLines() const
return m_showContourLines();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimContourMapProjection::showContourLabels() const
{
return m_showContourLines() && m_showContourLabels();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -659,6 +672,8 @@ void RimContourMapProjection::defineUiOrdering(QString uiConfigName, caf::PdmUiO
caf::PdmUiGroup* mainGroup = uiOrdering.addNewGroup("Projection Settings");
mainGroup->add(&m_relativeSampleSpacing);
mainGroup->add(&m_showContourLines);
mainGroup->add(&m_showContourLabels);
m_showContourLabels.uiCapability()->setUiReadOnly(!m_showContourLines());
mainGroup->add(&m_resultAggregation);
caf::PdmUiGroup* weightingGroup = uiOrdering.addNewGroup("Mean Weighting Options");
@@ -1314,6 +1329,7 @@ void RimContourMapProjection::updateGridInformation()
m_mainGrid = eclipseCase()->eclipseCaseData()->mainGrid();
m_sampleSpacing = m_relativeSampleSpacing * m_mainGrid->characteristicIJCellSize();
m_fullBoundingBox = eclipseCase()->activeCellsBoundingBox();
m_fullBoundingBox.expand(m_sampleSpacing * 2.0);
m_mapSize = calculateMapSize();
// Re-jig max point to be an exact multiple of cell size

71
ApplicationCode/ProjectDataModel/RimContourMapProjection.h
View File

@@ -29,6 +29,7 @@
#include "cvfBoundingBox.h"
#include "cvfGeometryBuilderFaceList.h"
#include "cvfString.h"
#include "cvfVector2.h"
class RigMainGrid;
@@ -45,6 +46,12 @@ class RimContourMapProjection : public RimCheckableNamedObject
{
CAF_PDM_HEADER_INIT;
public:
struct ContourPolygon
{
std::vector<cvf::Vec3d> vertices;
cvf::String label;
};
enum ResultAggregationEnum
{
RESULTS_TOP_VALUE,
@@ -60,49 +67,52 @@ public:
RESULTS_HC_COLUMN
};
typedef caf::AppEnum<ResultAggregationEnum> ResultAggregation;
typedef std::vector<cvf::ref<cvf::Vec3fArray>> ContourPolygons;
typedef std::vector<ContourPolygon> ContourPolygons;
RimContourMapProjection();
~RimContourMapProjection() override;
void generateVertices(cvf::Vec3fArray* vertices, const caf::DisplayCoordTransform* displayCoordTransform);
ContourPolygons generateContourPolygons(const caf::DisplayCoordTransform* displayCoordTransform);
cvf::ref<cvf::Vec3fArray> generatePickPointPolygon(const caf::DisplayCoordTransform* displayCoordTransform);
void generateResults();
std::vector<cvf::Vec3d> generateVertices();
void generateContourPolygons();
std::vector<cvf::Vec3d> generatePickPointPolygon();
void generateResults();
ResultAggregation resultAggregation() const;
double sampleSpacing() const;
double sampleSpacingFactor() const;
bool showContourLines() const;
const std::vector<ContourPolygons>& contourPolygons() const;
QString resultAggregationText() const;
QString resultDescriptionText() const;
QString weightingParameter() const;
ResultAggregation resultAggregation() const;
double sampleSpacing() const;
double sampleSpacingFactor() const;
bool showContourLines() const;
bool showContourLabels() const;
double maxValue() const;
double minValue() const;
double meanValue() const;
double sumAllValues() const;
QString resultAggregationText() const;
QString resultDescriptionText() const;
QString weightingParameter() const;
cvf::Vec2ui numberOfElementsIJ() const;
cvf::Vec2ui numberOfVerticesIJ() const;
double maxValue() const;
double minValue() const;
double meanValue() const;
double sumAllValues() const;
bool isColumnResult() const;
cvf::Vec2ui numberOfElementsIJ() const;
cvf::Vec2ui numberOfVerticesIJ() const;
double valueAtVertex(uint i, uint j) const;
bool hasResultAtVertex(uint i, uint j) const;
bool isColumnResult() const;
RimRegularLegendConfig* legendConfig() const;
void updateLegend();
double valueAtVertex(uint i, uint j) const;
bool hasResultAtVertex(uint i, uint j) const;
uint numberOfCells() const;
uint numberOfValidCells() const;
size_t numberOfVertices() const;
RimRegularLegendConfig* legendConfig() const;
void updateLegend();
void updatedWeightingResult();
uint numberOfCells() const;
uint numberOfValidCells() const;
size_t numberOfVertices() const;
bool checkForMapIntersection(const cvf::Vec3d& localPoint3d, cvf::Vec2d* contourMapPoint, cvf::Vec2ui* contourMapCell, double* valueAtPoint) const;
void setPickPoint(cvf::Vec2d pickedPoint);
void updatedWeightingResult();
bool checkForMapIntersection(const cvf::Vec3d& localPoint3d, cvf::Vec2d* contourMapPoint, cvf::Vec2ui* contourMapCell, double* valueAtPoint) const;
void setPickPoint(cvf::Vec2d pickedPoint);
protected:
void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
@@ -159,8 +169,10 @@ protected:
caf::PdmField<double> m_relativeSampleSpacing;
caf::PdmField<ResultAggregation> m_resultAggregation;
caf::PdmField<bool> m_showContourLines;
caf::PdmField<bool> m_showContourLabels;
caf::PdmField<bool> m_weightByParameter;
caf::PdmChildField<RimEclipseResultDefinition*> m_weightingResult;
cvf::ref<cvf::UByteArray> m_cellGridIdxVisibility;
std::vector<double> m_aggregatedResults;
@@ -177,4 +189,5 @@ protected:
cvf::Vec2ui m_mapSize;
cvf::BoundingBox m_fullBoundingBox;
double m_sampleSpacing;
std::vector<ContourPolygons> m_contourPolygons;
};

1
ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

@@ -242,7 +242,6 @@ void RimEclipseResultCase::reloadEclipseGridFile()
{
m_gridAndWellDataIsReadFromFile = false;
m_activeCellInfoIsReadFromFile = false;
m_timeStepFilter->reset();
setReservoirData(nullptr);
openReserviorCase();
}

15
ApplicationCode/ProjectDataModel/RimTimeStepFilter.cpp
View File

@@ -181,21 +181,6 @@ bool RimTimeStepFilter::updateFilteredTimeStepsFromUi()
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimTimeStepFilter::reset()
{
m_filterType = TS_ALL;
m_filteredTimeSteps.v().clear();
m_filteredTimeStepsUi.v().clear();
m_firstTimeStep = 0;
m_lastTimeStep = 0;
m_interval = 1;
m_dateFormat = QString("yyyy-MM-dd");
m_timeStepNamesFromFile.v().clear();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

3
ApplicationCode/ProjectDataModel/RimTimeStepFilter.h
View File

@@ -52,9 +52,6 @@ public:
void setTimeStepsFromFile(const std::vector<std::pair<QString, QDateTime>>& timeSteps);
std::vector<size_t> filteredTimeSteps() const;
bool updateFilteredTimeStepsFromUi();
void reset();
private:
std::vector<std::pair<QString, QDateTime>> allTimeSteps() const;
std::vector<int> filteredTimeStepIndicesFromUi() const;

19
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp
View File

@@ -660,6 +660,25 @@ void RimEnsembleCurveSet::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrd
}
uiTreeOrdering.skipRemainingChildren(true);
// Reset dynamic icon
this->setUiIcon(QIcon());
// Get static one
QIcon icon = this->uiIcon();
RimEnsembleCurveSetCollection* coll = nullptr;
this->firstAncestorOrThisOfType(coll);
if (coll && coll->curveSetForSourceStepping() == this)
{
QPixmap combined = icon.pixmap(16, 16);
QPainter painter(&combined);
QPixmap updownpixmap(":/StepUpDownCorner16x16.png");
painter.drawPixmap(0,0,updownpixmap);
icon = QIcon(combined);
}
this->setUiIcon(icon);
}
//--------------------------------------------------------------------------------------------------

92
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSetCollection.cpp
View File

@@ -20,6 +20,7 @@
#include "RiaApplication.h"
#include "RiaColorTables.h"
#include "RiaStdStringTools.h"
#include "RifReaderEclipseSummary.h"
@@ -50,6 +51,13 @@ RimEnsembleCurveSetCollection::RimEnsembleCurveSetCollection()
CAF_PDM_InitField(&m_showCurves, "IsActive", true, "Show Curves", "", "", "");
m_showCurves.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_ySourceStepping, "YSourceStepping", "", "", "", "");
m_ySourceStepping = new RimSummaryPlotSourceStepping;
m_ySourceStepping->setSourceSteppingType(RimSummaryPlotSourceStepping::Y_AXIS);
m_ySourceStepping.uiCapability()->setUiHidden(true);
m_ySourceStepping.uiCapability()->setUiTreeChildrenHidden(true);
m_ySourceStepping.xmlCapability()->disableIO();
}
//--------------------------------------------------------------------------------------------------
@@ -193,6 +201,80 @@ size_t RimEnsembleCurveSetCollection::curveSetCount() const
return m_curveSets.size();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<caf::PdmFieldHandle*> RimEnsembleCurveSetCollection::fieldsToShowInToolbar()
{
if (m_ySourceStepping)
{
return m_ySourceStepping->fieldsToShowInToolbar();
}
return std::vector<caf::PdmFieldHandle*>();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEnsembleCurveSetCollection::setCurveSetForSourceStepping(RimEnsembleCurveSet* curveSet)
{
m_curveSetForSourceStepping = curveSet;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEnsembleCurveSet* RimEnsembleCurveSetCollection::curveSetForSourceStepping() const
{
return m_curveSetForSourceStepping;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimEnsembleCurveSet*> RimEnsembleCurveSetCollection::curveSetsForSourceStepping() const
{
std::vector<RimEnsembleCurveSet*> steppingCurveSets;
if (m_curveSetForSourceStepping)
{
steppingCurveSets.push_back(m_curveSetForSourceStepping);
{
// Add corresponding history/summary curve with or without H
const std::string historyIdentifier = "H";
std::string quantity = m_curveSetForSourceStepping->summaryAddress().quantityName();
std::string candidateName;
if (RiaStdStringTools::endsWith(quantity, historyIdentifier))
{
candidateName = quantity.substr(0, quantity.size() - 1);
}
else
{
candidateName = quantity + historyIdentifier;
}
for (const auto& c : curveSets())
{
if (c->summaryAddress().quantityName() == candidateName)
{
steppingCurveSets.push_back(c);
}
}
}
}
else
{
steppingCurveSets = curveSets();
}
return steppingCurveSets;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -228,6 +310,16 @@ void RimEnsembleCurveSetCollection::fieldChangedByUi(const caf::PdmFieldHandle*
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEnsembleCurveSetCollection::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
auto group = uiOrdering.addNewGroup("Data Source");
m_ySourceStepping()->uiOrdering(uiConfigName, *group);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

14
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSetCollection.h
View File

@@ -25,6 +25,8 @@
#include "cafPdmObject.h"
class RimEnsembleCurveSet;
class RimSummaryPlotSourceStepping;
class RimSummaryCurve;
class QwtPlot;
class QwtPlotCurve;
@@ -55,9 +57,16 @@ public:
std::vector<RimEnsembleCurveSet*> curveSets() const;
size_t curveSetCount() const;
void deleteAllCurveSets();
void setCurrentSummaryCurveSet(RimEnsembleCurveSet* curveSet);
// Functions related to source stepping
std::vector<caf::PdmFieldHandle*> fieldsToShowInToolbar();
void setCurveSetForSourceStepping(RimEnsembleCurveSet* curve);
RimEnsembleCurveSet* curveSetForSourceStepping() const;
std::vector<RimEnsembleCurveSet*> curveSetsForSourceStepping() const;
private:
caf::PdmFieldHandle* objectToggleField() override;
@@ -65,10 +74,15 @@ private:
void fieldChangedByUi(const caf::PdmFieldHandle* changedField,
const QVariant& oldValue, const QVariant& newValue) override;
void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
private:
caf::PdmField<bool> m_showCurves;
caf::PdmChildArrayField<RimEnsembleCurveSet*> m_curveSets;
caf::PdmChildField<RimSummaryPlotSourceStepping*> m_ySourceStepping;
caf::PdmPointer<RimEnsembleCurveSet> m_currentEnsembleCurveSet;
caf::PdmPointer<RimEnsembleCurveSet> m_curveSetForSourceStepping;
};

27
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.cpp
View File

@@ -565,6 +565,33 @@ void RimSummaryCurve::updateLegendsInPlot()
plot->updateAllLegendItems();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurve::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
{
RimPlotCurve::defineUiTreeOrdering(uiTreeOrdering, uiConfigName);
// Reset dynamic icon
this->setUiIcon(QIcon());
// Get static one
QIcon icon = this->uiIcon();
RimSummaryCurveCollection* coll = nullptr;
this->firstAncestorOrThisOfType(coll);
if (coll && coll->curveForSourceStepping() == this)
{
QPixmap combined = icon.pixmap(16, 16);
QPainter painter(&combined);
QPixmap updownpixmap(":/StepUpDownCorner16x16.png");
painter.drawPixmap(0,0,updownpixmap);
icon = QIcon(combined);
}
this->setUiIcon(icon);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

3
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.h
View File

@@ -93,6 +93,9 @@ protected:
void updateLegendsInPlot() override;
void defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "") override;
private:
RifSummaryReaderInterface* valuesSummaryReaderX() const;
RifSummaryReaderInterface* valuesSummaryReaderY() const;

83
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveCollection.cpp
View File

@@ -19,6 +19,7 @@
#include "RimSummaryCurveCollection.h"
#include "RiaApplication.h"
#include "RiaStdStringTools.h"
#include "RifReaderEclipseSummary.h"
@@ -192,6 +193,72 @@ std::vector<RimSummaryCurve*> RimSummaryCurveCollection::curves() const
return m_curves.childObjects();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimSummaryCurve*> RimSummaryCurveCollection::curvesForSourceStepping(RimSummaryPlotSourceStepping::SourceSteppingType steppingType) const
{
std::vector<RimSummaryCurve*> stepCurves;
if (m_curveForSourceStepping)
{
stepCurves.push_back(m_curveForSourceStepping);
{
// Add corresponding history/summary curve with or without H
const std::string historyIdentifier = "H";
std::string quantity;
if (steppingType == RimSummaryPlotSourceStepping::X_AXIS)
{
quantity = m_curveForSourceStepping->summaryAddressX().quantityName();
}
else if (steppingType == RimSummaryPlotSourceStepping::Y_AXIS)
{
quantity = m_curveForSourceStepping->summaryAddressY().quantityName();
}
std::string candidateName;
if (RiaStdStringTools::endsWith(quantity, historyIdentifier))
{
candidateName = quantity.substr(0, quantity.size() - 1);
}
else
{
candidateName = quantity + historyIdentifier;
}
for (const auto& c : curves())
{
if (steppingType == RimSummaryPlotSourceStepping::X_AXIS)
{
if (c->summaryCaseX() == m_curveForSourceStepping->summaryCaseX() &&
c->summaryAddressX().quantityName() == candidateName)
{
stepCurves.push_back(c);
}
}
else if (steppingType == RimSummaryPlotSourceStepping::Y_AXIS)
{
if (c->summaryCaseY() == m_curveForSourceStepping->summaryCaseY() &&
c->summaryAddressY().quantityName() == candidateName)
{
stepCurves.push_back(c);
}
}
}
}
}
else
{
stepCurves = curves();
}
return stepCurves;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -355,6 +422,22 @@ void RimSummaryCurveCollection::setCurveAsTopZWithinCategory(RimSummaryCurve* cu
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveCollection::setCurveForSourceStepping(RimSummaryCurve* curve)
{
m_curveForSourceStepping = curve;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryCurve* RimSummaryCurveCollection::curveForSourceStepping() const
{
return m_curveForSourceStepping;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

8
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveCollection.h
View File

@@ -19,6 +19,8 @@
#pragma once
#include "RimSummaryPlotSourceStepping.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmChildField.h"
#include "cafPdmField.h"
@@ -29,7 +31,6 @@ class QwtPlot;
class QwtPlotCurve;
class RimSummaryCase;
class RimSummaryCurve;
class RimSummaryPlotSourceStepping;
class QKeyEvent;
//==================================================================================================
@@ -56,6 +57,7 @@ public:
void deleteCurve(RimSummaryCurve* curve);
std::vector<RimSummaryCurve*> curves() const;
std::vector<RimSummaryCurve*> curvesForSourceStepping(RimSummaryPlotSourceStepping::SourceSteppingType steppingType) const;
void deleteCurvesAssosiatedWithCase(RimSummaryCase* summaryCase);
void deleteAllCurves();
@@ -68,6 +70,9 @@ public:
void handleKeyPressEvent(QKeyEvent* keyEvent);
void setCurveAsTopZWithinCategory(RimSummaryCurve* curve);
void setCurveForSourceStepping(RimSummaryCurve* curve);
RimSummaryCurve* curveForSourceStepping() const;
private:
caf::PdmFieldHandle* objectToggleField() override;
@@ -88,5 +93,6 @@ private:
caf::PdmChildField<RimSummaryPlotSourceStepping*> m_unionSourceStepping;
caf::PdmPointer<RimSummaryCurve> m_currentSummaryCurve;
caf::PdmPointer<RimSummaryCurve> m_curveForSourceStepping;
};

16
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.cpp
View File

@@ -549,6 +549,22 @@ bool RimSummaryPlot::containsResamplableCurves() const
return !m_gridTimeHistoryCurves.empty() || resamplableSummaryCurveCount > 0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RimSummaryPlot::singleColorCurveCount() const
{
auto allCurveSets = ensembleCurveSetCollection()->curveSets();
size_t colorIndex = std::count_if(allCurveSets.begin(), allCurveSets.end(), [](RimEnsembleCurveSet* curveSet)
{
return curveSet->colorMode() == RimEnsembleCurveSet::SINGLE_COLOR;
});
colorIndex += curveCount();
return colorIndex;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.h
View File

@@ -132,6 +132,8 @@ public:
void updatePlotInfoLabel();
bool containsResamplableCurves() const;
size_t singleColorCurveCount() const;
// RimViewWindow overrides
public:
QWidget* createViewWidget(QWidget* mainWindowParent) override;

679
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlotSourceStepping.cpp
View File

@@ -25,6 +25,8 @@
#include "RifSummaryReaderInterface.h"
#include "RimDataSourceSteppingTools.h"
#include "RimEnsembleCurveSet.h"
#include "RimEnsembleCurveSetCollection.h"
#include "RimProject.h"
#include "RimSummaryCase.h"
#include "RimSummaryCaseMainCollection.h"
@@ -35,6 +37,7 @@
#include "RiuPlotMainWindow.h"
#include "RiaStdStringTools.h"
#include "cafPdmUiComboBoxEditor.h"
#include "cafPdmUiItem.h"
#include "cafPdmUiListEditor.h"
@@ -51,11 +54,22 @@ RimSummaryPlotSourceStepping::RimSummaryPlotSourceStepping()
CAF_PDM_InitObject("Summary Curves Modifier", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_summaryCase, "CurveCase", "Case", "", "", "");
CAF_PDM_InitField(&m_includeEnsembleCasesForCaseStepping,
"IncludeEnsembleCasesForCaseStepping",
false,
"Allow Stepping on Ensemble cases",
"",
"",
"");
CAF_PDM_InitFieldNoDefault(&m_wellName, "WellName", "Well Name", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_wellGroupName, "GroupName", "Group Name", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_region, "Region", "Region", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_quantity, "Quantities", "Quantity", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_ensemble, "Ensemble", "Ensemble", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_placeholderForLabel, "Placeholder", "", "", "", "");
m_placeholderForLabel = "No common identifiers detected";
m_placeholderForLabel.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::TOP);
@@ -88,6 +102,22 @@ void RimSummaryPlotSourceStepping::applyPrevCase()
modifyCurrentIndex(&m_summaryCase, -1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryPlotSourceStepping::applyNextEnsemble()
{
modifyCurrentIndex(&m_ensemble, 1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryPlotSourceStepping::applyPrevEnsemble()
{
modifyCurrentIndex(&m_ensemble, -1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -162,85 +192,159 @@ void RimSummaryPlotSourceStepping::defineUiOrdering(QString uiConfigName, caf::P
QList<caf::PdmOptionItemInfo> RimSummaryPlotSourceStepping::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions,
bool* useOptionsOnly)
{
if (fieldNeedingOptions == &m_placeholderForLabel)
QList<caf::PdmOptionItemInfo> options;
if (fieldNeedingOptions == &m_includeEnsembleCasesForCaseStepping)
{
return QList<caf::PdmOptionItemInfo>();
return caf::PdmObject::calculateValueOptions(fieldNeedingOptions, useOptionsOnly);
}
if (fieldNeedingOptions == &m_summaryCase)
else if (fieldNeedingOptions == &m_placeholderForLabel)
{
QList<caf::PdmOptionItemInfo> options;
RimProject* proj = RiaApplication::instance()->project();
for (auto sumCase : proj->allSummaryCases())
options;
}
else if (fieldNeedingOptions == &m_summaryCase)
{
auto summaryCases = RimSummaryPlotSourceStepping::summaryCasesForSourceStepping();
for (auto sumCase : summaryCases)
{
options.append(caf::PdmOptionItemInfo(sumCase->caseName(), sumCase));
}
return options;
}
else if (fieldNeedingOptions == &m_ensemble)
{
RimProject* proj = RiaApplication::instance()->project();
for (auto ensemble : proj->summaryGroups())
{
if (ensemble->isEnsemble())
{
options.append(caf::PdmOptionItemInfo(ensemble->name(), ensemble));
}
}
std::vector<QString> identifierTexts;
return options;
}
std::vector<RifSummaryReaderInterface*> readers = summaryReadersForCurves();
if (!readers.empty())
{
RiaSummaryCurveAnalyzer* analyzer = analyzerForReader(readers.front());
if (fieldNeedingOptions == &m_wellName)
if (fieldNeedingOptions == &m_quantity)
{
identifierTexts = analyzer->identifierTexts(RifEclipseSummaryAddress::SUMMARY_WELL);
}
else if (fieldNeedingOptions == &m_region)
{
identifierTexts = analyzer->identifierTexts(RifEclipseSummaryAddress::SUMMARY_REGION);
}
else if (fieldNeedingOptions == &m_wellGroupName)
{
identifierTexts = analyzer->identifierTexts(RifEclipseSummaryAddress::SUMMARY_WELL_GROUP);
}
else if (fieldNeedingOptions == &m_quantity)
{
RimSummaryCurveCollection* curveCollection = nullptr;
this->firstAncestorOrThisOfTypeAsserted(curveCollection);
RifEclipseSummaryAddress::SummaryVarCategory category = RifEclipseSummaryAddress::SUMMARY_FIELD;
if (curveCollection->curves().size() > 0)
auto addresses = addressesCurveCollection();
if (!addresses.empty())
{
category = curveCollection->curves()[0]->summaryAddressY().category();
category = addresses.begin()->category();
}
RiaSummaryCurveAnalyzer quantityAnalyzer;
std::map<QString, QString> displayAndValueStrings;
for (auto reader : readers)
{
if (reader != nullptr)
RiaSummaryCurveAnalyzer quantityAnalyzer;
for (auto reader : readers)
{
auto subset = RiaSummaryCurveAnalyzer::addressesForCategory(reader->allResultAddresses(), category);
quantityAnalyzer.appendAdresses(subset);
if (reader != nullptr)
{
auto subset = RiaSummaryCurveAnalyzer::addressesForCategory(reader->allResultAddresses(), category);
quantityAnalyzer.appendAdresses(subset);
}
}
RiaSummaryCurveAnalyzer analyzerForCurves;
analyzerForCurves.appendAdresses(addressesCurveCollection());
if (analyzerForCurves.quantityNamesWithHistory().empty())
{
auto quantities = quantityAnalyzer.quantities();
for (const auto& s : quantities)
{
QString valueString = QString::fromStdString(s);
displayAndValueStrings[valueString] = valueString;
}
}
else
{
auto quantitiesWithHistory = quantityAnalyzer.quantityNamesWithHistory();
for (const auto& s : quantitiesWithHistory)
{
QString valueString = QString::fromStdString(s);
QString displayString = valueString + " (H)";
displayAndValueStrings[displayString] = valueString;
}
auto quantitiesNoHistory = quantityAnalyzer.quantityNamesNoHistory();
for (const auto& s : quantitiesNoHistory)
{
QString valueString = QString::fromStdString(s);
displayAndValueStrings[valueString] = valueString;
}
}
}
for (const auto& quantity : quantityAnalyzer.quantities())
for (const auto& displayAndValue : displayAndValueStrings)
{
identifierTexts.push_back(QString::fromStdString(quantity));
options.append(caf::PdmOptionItemInfo(displayAndValue.first, displayAndValue.second));
}
if (options.isEmpty())
{
options.push_back(caf::PdmOptionItemInfo("None", "None"));
}
}
}
QList<caf::PdmOptionItemInfo> options;
if (identifierTexts.size() > 0)
{
for (const auto& text : identifierTexts)
else
{
options.append(caf::PdmOptionItemInfo(text, text));
RifEclipseSummaryAddress::SummaryVarCategory category = RifEclipseSummaryAddress::SUMMARY_INVALID;
if (fieldNeedingOptions == &m_wellName)
{
category = RifEclipseSummaryAddress::SUMMARY_WELL;
}
else if (fieldNeedingOptions == &m_region)
{
category = RifEclipseSummaryAddress::SUMMARY_REGION;
}
else if (fieldNeedingOptions == &m_wellGroupName)
{
category = RifEclipseSummaryAddress::SUMMARY_WELL_GROUP;
}
std::set<QString> identifierTexts;
if (category != RifEclipseSummaryAddress::SUMMARY_INVALID)
{
for (auto reader : readers)
{
auto analyzer = analyzerForReader(reader);
if (analyzer)
{
for (const auto& t : analyzer->identifierTexts(category))
{
identifierTexts.insert(t);
}
}
}
}
if (!identifierTexts.empty())
{
for (const auto& text : identifierTexts)
{
options.append(caf::PdmOptionItemInfo(text, text));
}
}
else
{
options.push_back(caf::PdmOptionItemInfo("None", "None"));
}
}
}
else
{
options.push_back(caf::PdmOptionItemInfo("None", "None"));
}
return options;
}
@@ -252,27 +356,90 @@ void RimSummaryPlotSourceStepping::fieldChangedByUi(const caf::PdmFieldHandle* c
const QVariant& oldValue,
const QVariant& newValue)
{
std::vector<RimSummaryCurve*> curves;
RimSummaryCurveCollection* curveCollection = nullptr;
this->firstAncestorOrThisOfTypeAsserted(curveCollection);
this->firstAncestorOrThisOfType(curveCollection);
if (curveCollection)
{
curves = curveCollection->curves();
}
RimEnsembleCurveSetCollection* ensembleCurveColl = nullptr;
this->firstAncestorOrThisOfType(ensembleCurveColl);
if (changedField == &m_includeEnsembleCasesForCaseStepping)
{
if (curveCollection)
{
curveCollection->updateConnectedEditors();
}
if (ensembleCurveColl)
{
ensembleCurveColl->updateConnectedEditors();
}
RiuPlotMainWindow* mainPlotWindow = RiaApplication::instance()->getOrCreateMainPlotWindow();
bool forceUpdateOfFieldsInToolbar = true;
mainPlotWindow->updateSummaryPlotToolBar(forceUpdateOfFieldsInToolbar);
return;
}
bool triggerLoadDataAndUpdate = false;
std::string oldValueString = oldValue.toString().toStdString();
std::string newValueString = newValue.toString().toStdString();
if (changedField == &m_summaryCase)
{
if (m_summaryCase())
{
for (auto curve : curveCollection->curves())
caf::PdmPointer<caf::PdmObjectHandle> variantHandle = oldValue.value<caf::PdmPointer<caf::PdmObjectHandle>>();
RimSummaryCase* previousCase = dynamic_cast<RimSummaryCase*>(variantHandle.p());
for (auto curve : curves)
{
if (isYAxisStepping())
{
bool doSetAppearance = curve->summaryCaseY()->isObservedData() != m_summaryCase->isObservedData();
curve->setSummaryCaseY(m_summaryCase);
if (doSetAppearance) curve->forceUpdateCurveAppearanceFromCaseType();
if (previousCase == curve->summaryCaseY())
{
bool doSetAppearance = curve->summaryCaseY()->isObservedData() != m_summaryCase->isObservedData();
curve->setSummaryCaseY(m_summaryCase);
if (doSetAppearance) curve->forceUpdateCurveAppearanceFromCaseType();
}
}
if (isXAxisStepping())
{
curve->setSummaryCaseX(m_summaryCase);
if (previousCase == curve->summaryCaseX())
{
curve->setSummaryCaseX(m_summaryCase);
}
}
}
triggerLoadDataAndUpdate = true;
}
m_wellName.uiCapability()->updateConnectedEditors();
m_wellGroupName.uiCapability()->updateConnectedEditors();
m_region.uiCapability()->updateConnectedEditors();
m_quantity.uiCapability()->updateConnectedEditors();
}
else if (changedField == &m_ensemble)
{
if (m_ensemble() && ensembleCurveColl)
{
caf::PdmPointer<caf::PdmObjectHandle> variantHandle = oldValue.value<caf::PdmPointer<caf::PdmObjectHandle>>();
RimSummaryCaseCollection* previousCollection = dynamic_cast<RimSummaryCaseCollection*>(variantHandle.p());
for (auto curveSet : ensembleCurveColl->curveSets())
{
if (curveSet->summaryCaseCollection() == previousCollection)
{
curveSet->setSummaryCaseCollection(m_ensemble);
}
}
@@ -286,28 +453,30 @@ void RimSummaryPlotSourceStepping::fieldChangedByUi(const caf::PdmFieldHandle* c
}
else if (changedField == &m_wellName)
{
for (auto curve : curveCollection->curves())
for (auto curve : curves)
{
if (isYAxisStepping())
{
RifEclipseSummaryAddress adr = curve->summaryAddressY();
if (RifEclipseSummaryAddress::isDependentOnWellName(adr))
{
adr.setWellName(m_wellName().toStdString());
curve->setSummaryAddressY(adr);
}
updateAddressIfMatching(oldValue, newValue, RifEclipseSummaryAddress::SUMMARY_WELL, &adr);
curve->setSummaryAddressY(adr);
}
if (isXAxisStepping())
{
RifEclipseSummaryAddress adr = curve->summaryAddressX();
if (RifEclipseSummaryAddress::isDependentOnWellName(adr))
{
adr.setWellName(m_wellName().toStdString());
updateAddressIfMatching(oldValue, newValue, RifEclipseSummaryAddress::SUMMARY_WELL, &adr);
curve->setSummaryAddressX(adr);
}
}
curve->setSummaryAddressX(adr);
}
if (ensembleCurveColl)
{
for (auto curveSet : ensembleCurveColl->curveSets())
{
auto adr = curveSet->summaryAddress();
updateAddressIfMatching(oldValue, newValue, RifEclipseSummaryAddress::SUMMARY_WELL, &adr);
curveSet->setSummaryAddress(adr);
}
}
@@ -315,28 +484,30 @@ void RimSummaryPlotSourceStepping::fieldChangedByUi(const caf::PdmFieldHandle* c
}
else if (changedField == &m_region)
{
for (auto curve : curveCollection->curves())
for (auto curve : curves)
{
if (isYAxisStepping())
{
RifEclipseSummaryAddress adr = curve->summaryAddressY();
if (adr.category() == RifEclipseSummaryAddress::SUMMARY_REGION)
{
adr.setRegion(m_region());
curve->setSummaryAddressY(adr);
}
updateAddressIfMatching(oldValue, newValue, RifEclipseSummaryAddress::SUMMARY_REGION, &adr);
curve->setSummaryAddressY(adr);
}
if (isXAxisStepping())
{
RifEclipseSummaryAddress adr = curve->summaryAddressX();
if (adr.category() == RifEclipseSummaryAddress::SUMMARY_REGION)
{
adr.setRegion(m_region());
updateAddressIfMatching(oldValue, newValue, RifEclipseSummaryAddress::SUMMARY_REGION, &adr);
curve->setSummaryAddressX(adr);
}
}
curve->setSummaryAddressX(adr);
}
if (ensembleCurveColl)
{
for (auto curveSet : ensembleCurveColl->curveSets())
{
auto adr = curveSet->summaryAddress();
updateAddressIfMatching(oldValue, newValue, RifEclipseSummaryAddress::SUMMARY_REGION, &adr);
curveSet->setSummaryAddress(adr);
}
}
@@ -344,51 +515,61 @@ void RimSummaryPlotSourceStepping::fieldChangedByUi(const caf::PdmFieldHandle* c
}
else if (changedField == &m_quantity)
{
for (auto curve : curveCollection->curves())
for (auto curve : curves)
{
if (isYAxisStepping())
{
RifEclipseSummaryAddress adr = curve->summaryAddressY();
adr.setQuantityName(m_quantity().toStdString());
auto adr = curve->summaryAddressY();
updateHistoryAndSummaryQuantityIfMatching(oldValue, newValue, &adr);
curve->setSummaryAddressY(adr);
}
if (isXAxisStepping())
{
RifEclipseSummaryAddress adr = curve->summaryAddressX();
adr.setQuantityName(m_quantity().toStdString());
auto adr = curve->summaryAddressX();
updateHistoryAndSummaryQuantityIfMatching(oldValue, newValue, &adr);
curve->setSummaryAddressX(adr);
}
}
if (ensembleCurveColl)
{
for (auto curveSet : ensembleCurveColl->curveSets())
{
auto adr = curveSet->summaryAddress();
updateHistoryAndSummaryQuantityIfMatching(oldValue, newValue, &adr);
curveSet->setSummaryAddress(adr);
}
}
triggerLoadDataAndUpdate = true;
}
else if (changedField == &m_wellGroupName)
{
for (auto curve : curveCollection->curves())
for (auto curve : curves)
{
if (isYAxisStepping())
{
RifEclipseSummaryAddress adr = curve->summaryAddressY();
if (adr.category() == RifEclipseSummaryAddress::SUMMARY_WELL_GROUP)
{
adr.setWellGroupName(m_wellGroupName().toStdString());
curve->setSummaryAddressY(adr);
}
updateAddressIfMatching(oldValue, newValue, RifEclipseSummaryAddress::SUMMARY_WELL_GROUP, &adr);
curve->setSummaryAddressY(adr);
}
if (isXAxisStepping())
{
RifEclipseSummaryAddress adr = curve->summaryAddressX();
if (adr.category() == RifEclipseSummaryAddress::SUMMARY_WELL_GROUP)
{
adr.setWellGroupName(m_wellGroupName().toStdString());
updateAddressIfMatching(oldValue, newValue, RifEclipseSummaryAddress::SUMMARY_WELL_GROUP, &adr);
curve->setSummaryAddressX(adr);
}
}
curve->setSummaryAddressX(adr);
}
if (ensembleCurveColl)
{
for (auto curveSet : ensembleCurveColl->curveSets())
{
auto adr = curveSet->summaryAddress();
updateAddressIfMatching(oldValue, newValue, RifEclipseSummaryAddress::SUMMARY_WELL_GROUP, &adr);
curveSet->setSummaryAddress(adr);
}
}
@@ -403,12 +584,20 @@ void RimSummaryPlotSourceStepping::fieldChangedByUi(const caf::PdmFieldHandle* c
summaryPlot->updatePlotTitle();
summaryPlot->loadDataAndUpdate();
if (ensembleCurveColl)
{
ensembleCurveColl->updateConnectedEditors();
}
RimSummaryCrossPlot* summaryCrossPlot = dynamic_cast<RimSummaryCrossPlot*>(summaryPlot);
if (summaryCrossPlot)
{
// Trigger update of curve collection (and summary toolbar in main window), as the visibility of combo boxes might
// have been changed due to the updates in this function
curveCollection->updateConnectedEditors();
if (curveCollection)
{
curveCollection->updateConnectedEditors();
}
RiuPlotMainWindow* mainPlotWindow = RiaApplication::instance()->mainPlotWindow();
mainPlotWindow->updateSummaryPlotToolBar();
@@ -423,18 +612,38 @@ std::vector<RifSummaryReaderInterface*> RimSummaryPlotSourceStepping::summaryRea
{
std::vector<RifSummaryReaderInterface*> readers;
RimSummaryCurveCollection* curveCollection = nullptr;
this->firstAncestorOrThisOfTypeAsserted(curveCollection);
this->firstAncestorOrThisOfType(curveCollection);
for (auto curve : curveCollection->curves())
if (curveCollection)
{
if (isYAxisStepping() && curve->summaryCaseY())
for (auto curve : curveCollection->curves())
{
readers.push_back(curve->summaryCaseY()->summaryReader());
}
if (isYAxisStepping() && curve->summaryCaseY())
{
readers.push_back(curve->summaryCaseY()->summaryReader());
}
if (isXAxisStepping() && curve->summaryCaseX())
if (isXAxisStepping() && curve->summaryCaseX())
{
readers.push_back(curve->summaryCaseX()->summaryReader());
}
}
}
RimEnsembleCurveSetCollection* ensembleCollection = nullptr;
this->firstAncestorOrThisOfType(ensembleCollection);
if (ensembleCollection)
{
auto curveSets = ensembleCollection->curveSets();
for (const RimEnsembleCurveSet* curveSet : curveSets)
{
readers.push_back(curve->summaryCaseX()->summaryReader());
for (auto curve : curveSet->curves())
{
if (isYAxisStepping() && curve->summaryCaseY())
{
readers.push_back(curve->summaryCaseY()->summaryReader());
}
}
}
}
@@ -477,19 +686,31 @@ std::set<RifEclipseSummaryAddress> RimSummaryPlotSourceStepping::addressesCurveC
RimSummaryCurveCollection* curveCollection = nullptr;
this->firstAncestorOrThisOfType(curveCollection);
if (!curveCollection) return addresses;
auto curves = curveCollection->curves();
for (auto c : curves)
if (curveCollection)
{
if (isYAxisStepping())
auto curves = curveCollection->curvesForSourceStepping(m_sourceSteppingType);
for (auto c : curves)
{
addresses.insert(c->summaryAddressY());
}
if (isYAxisStepping())
{
addresses.insert(c->summaryAddressY());
}
if (isXAxisStepping())
if (isXAxisStepping())
{
addresses.insert(c->summaryAddressX());
}
}
}
RimEnsembleCurveSetCollection* ensembleCollection = nullptr;
this->firstAncestorOrThisOfType(ensembleCollection);
if (ensembleCollection)
{
auto curveSets = ensembleCollection->curveSetsForSourceStepping();
for (const RimEnsembleCurveSet* curveSet : curveSets)
{
addresses.insert(c->summaryAddressX());
addresses.insert(curveSet->summaryAddress());
}
}
@@ -508,7 +729,7 @@ std::set<RimSummaryCase*> RimSummaryPlotSourceStepping::summaryCasesCurveCollect
if (!curveCollection) return sumCases;
auto curves = curveCollection->curves();
auto curves = curveCollection->curvesForSourceStepping(m_sourceSteppingType);
for (auto c : curves)
{
if (isYAxisStepping())
@@ -531,10 +752,12 @@ std::set<RimSummaryCase*> RimSummaryPlotSourceStepping::summaryCasesCurveCollect
std::vector<caf::PdmFieldHandle*> RimSummaryPlotSourceStepping::computeVisibleFieldsAndSetFieldVisibility()
{
m_summaryCase.uiCapability()->setUiHidden(true);
m_includeEnsembleCasesForCaseStepping.uiCapability()->setUiHidden(true);
m_wellName.uiCapability()->setUiHidden(true);
m_wellGroupName.uiCapability()->setUiHidden(true);
m_region.uiCapability()->setUiHidden(true);
m_quantity.uiCapability()->setUiHidden(true);
m_ensemble.uiCapability()->setUiHidden(true);
std::vector<caf::PdmFieldHandle*> fields;
@@ -549,61 +772,108 @@ std::vector<caf::PdmFieldHandle*> RimSummaryPlotSourceStepping::computeVisibleFi
m_summaryCase.uiCapability()->setUiHidden(false);
fields.push_back(&m_summaryCase);
m_includeEnsembleCasesForCaseStepping.uiCapability()->setUiHidden(false);
}
}
RiaSummaryCurveAnalyzer analyzer;
analyzer.appendAdresses(addressesCurveCollection());
RifEclipseSummaryAddress::SummaryVarCategory category = RifEclipseSummaryAddress::SUMMARY_INVALID;
auto ensembleColl = ensembleCollection();
if (ensembleColl.size() == 1)
{
if (analyzer.categories().size() == 1)
RimProject* proj = RiaApplication::instance()->project();
if (proj->summaryGroups().size() > 1)
{
category = *(analyzer.categories().begin());
m_ensemble = *(ensembleColl.begin());
m_ensemble.uiCapability()->setUiHidden(false);
fields.push_back(&m_ensemble);
}
}
if (category != RifEclipseSummaryAddress::SUMMARY_INVALID)
std::vector<caf::PdmFieldHandle*> fieldsCommonForAllCurves;
{
if (analyzer.wellNames().size() == 1)
{
QString txt = QString::fromStdString(*(analyzer.wellNames().begin()));
m_wellName = txt;
m_wellName.uiCapability()->setUiHidden(false);
RiaSummaryCurveAnalyzer analyzer;
analyzer.appendAdresses(addressesCurveCollection());
fields.push_back(&m_wellName);
RifEclipseSummaryAddress::SummaryVarCategory category = RifEclipseSummaryAddress::SUMMARY_INVALID;
{
if (analyzer.categories().size() == 1)
{
category = *(analyzer.categories().begin());
}
}
if (analyzer.wellGroupNames().size() == 1)
if (category != RifEclipseSummaryAddress::SUMMARY_INVALID)
{
QString txt = QString::fromStdString(*(analyzer.wellGroupNames().begin()));
m_wellGroupName = txt;
m_wellGroupName.uiCapability()->setUiHidden(false);
if (analyzer.wellNames().size() == 1)
{
QString txt = QString::fromStdString(*(analyzer.wellNames().begin()));
m_wellName = txt;
m_wellName.uiCapability()->setUiHidden(false);
fields.push_back(&m_wellGroupName);
fieldsCommonForAllCurves.push_back(&m_wellName);
}
if (analyzer.wellGroupNames().size() == 1)
{
QString txt = QString::fromStdString(*(analyzer.wellGroupNames().begin()));
m_wellGroupName = txt;
m_wellGroupName.uiCapability()->setUiHidden(false);
fieldsCommonForAllCurves.push_back(&m_wellGroupName);
}
if (analyzer.regionNumbers().size() == 1)
{
m_region = *(analyzer.regionNumbers().begin());
m_region.uiCapability()->setUiHidden(false);
fieldsCommonForAllCurves.push_back(&m_region);
}
if (!analyzer.quantityNameForTitle().empty())
{
QString txt = QString::fromStdString(analyzer.quantityNameForTitle());
m_quantity = txt;
m_quantity.uiCapability()->setUiHidden(false);
fieldsCommonForAllCurves.push_back(&m_quantity);
}
}
}
if (analyzer.regionNumbers().size() == 1)
{
m_region = *(analyzer.regionNumbers().begin());
m_region.uiCapability()->setUiHidden(false);
fields.push_back(&m_region);
}
if (analyzer.quantities().size() == 1)
{
QString txt = QString::fromStdString(*(analyzer.quantities().begin()));
m_quantity = txt;
m_quantity.uiCapability()->setUiHidden(false);
fields.push_back(&m_quantity);
}
for (const auto& f : fieldsCommonForAllCurves)
{
fields.push_back(f);
}
return fields;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<RimSummaryCaseCollection*> RimSummaryPlotSourceStepping::ensembleCollection() const
{
std::set<RimSummaryCaseCollection*> sumCases;
RimEnsembleCurveSetCollection* curveCollection = nullptr;
this->firstAncestorOrThisOfType(curveCollection);
if (!curveCollection) return sumCases;
auto curves = curveCollection->curveSets();
for (auto c : curves)
{
sumCases.insert(c->summaryCaseCollection());
}
return sumCases;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -656,6 +926,119 @@ void RimSummaryPlotSourceStepping::modifyCurrentIndex(caf::PdmValueField* valueF
RimDataSourceSteppingTools::modifyCurrentIndex(valueField, options, indexOffset);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSummaryPlotSourceStepping::updateAddressIfMatching(const QVariant& oldValue,
const QVariant& newValue,
RifEclipseSummaryAddress::SummaryVarCategory category,
RifEclipseSummaryAddress* adr)
{
if (!adr) return false;
if (category == RifEclipseSummaryAddress::SUMMARY_REGION)
{
int oldInt = oldValue.toInt();
int newInt = newValue.toInt();
if (adr->regionNumber() == oldInt)
{
adr->setRegion(newInt);
return true;
}
}
else if (category == RifEclipseSummaryAddress::SUMMARY_WELL_GROUP)
{
std::string oldString = oldValue.toString().toStdString();
std::string newString = newValue.toString().toStdString();
if (adr->wellGroupName() == oldString)
{
adr->setWellGroupName(newString);
return true;
}
}
else if (RifEclipseSummaryAddress::isDependentOnWellName(category))
{
std::string oldString = oldValue.toString().toStdString();
std::string newString = newValue.toString().toStdString();
if (adr->wellName() == oldString)
{
adr->setWellName(newString);
return true;
}
}
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSummaryPlotSourceStepping::updateHistoryAndSummaryQuantityIfMatching(const QVariant& oldValue,
const QVariant& newValue,
RifEclipseSummaryAddress* adr)
{
if (!adr) return false;
std::string oldString = oldValue.toString().toStdString();
std::string newString = newValue.toString().toStdString();
if (adr->quantityName() == oldString)
{
adr->setQuantityName(newString);
return true;
}
std::string correspondingOldString = RiaSummaryCurveAnalyzer::correspondingHistorySummaryCurveName(oldString);
std::string correspondingNewString = RiaSummaryCurveAnalyzer::correspondingHistorySummaryCurveName(newString);
if (adr->quantityName() == correspondingOldString)
{
adr->setQuantityName(correspondingNewString);
return true;
}
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimSummaryCase*> RimSummaryPlotSourceStepping::summaryCasesForSourceStepping()
{
std::vector<RimSummaryCase*> cases;
RimProject* proj = RiaApplication::instance()->project();
for (auto sumCase : proj->allSummaryCases())
{
if (sumCase->isObservedData()) continue;
RimSummaryCaseCollection* sumCaseColl = nullptr;
sumCase->firstAncestorOrThisOfType(sumCaseColl);
if (sumCaseColl && sumCaseColl->isEnsemble())
{
if (m_includeEnsembleCasesForCaseStepping())
{
cases.push_back(sumCase);
}
}
else
{
cases.push_back(sumCase);
}
}
return cases;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

22
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlotSourceStepping.h
View File

@@ -31,7 +31,9 @@
#include <set>
class RimSummaryCase;
class RimSummaryCurve;
class RifSummaryReaderInterface;
class RimSummaryCaseCollection;
//==================================================================================================
///
@@ -56,6 +58,9 @@ public:
void applyNextCase();
void applyPrevCase();
void applyNextEnsemble();
void applyPrevEnsemble();
void applyNextQuantity();
void applyPrevQuantity();
@@ -83,6 +88,7 @@ private:
std::set<RifEclipseSummaryAddress> addressesCurveCollection() const;
std::set<RimSummaryCase*> summaryCasesCurveCollection() const;
std::vector<caf::PdmFieldHandle*> computeVisibleFieldsAndSetFieldVisibility();
std::set<RimSummaryCaseCollection*> ensembleCollection() const;
bool isXAxisStepping() const;
bool isYAxisStepping() const;
@@ -91,13 +97,29 @@ private:
void modifyCurrentIndex(caf::PdmValueField* valueField, int indexOffset);
static bool updateAddressIfMatching(const QVariant& oldValue,
const QVariant& newValue,
RifEclipseSummaryAddress::SummaryVarCategory category,
RifEclipseSummaryAddress* adr);
static bool updateHistoryAndSummaryQuantityIfMatching(const QVariant& oldValue,
const QVariant& newValue,
RifEclipseSummaryAddress* adr);
std::vector<RimSummaryCase*> summaryCasesForSourceStepping();
private:
caf::PdmPtrField<RimSummaryCase*> m_summaryCase;
caf::PdmPtrField<RimSummaryCaseCollection*> m_ensemble;
caf::PdmField<QString> m_wellName;
caf::PdmField<QString> m_wellGroupName;
caf::PdmField<int> m_region;
caf::PdmField<QString> m_quantity;
caf::PdmField<QString> m_placeholderForLabel;
caf::PdmField<bool> m_includeEnsembleCasesForCaseStepping;
SourceSteppingType m_sourceSteppingType;
std::pair<RifSummaryReaderInterface*, RiaSummaryCurveAnalyzer> m_curveAnalyzerForReader;