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 pre-proto

Browse Source
This commit is contained in:
Magne Sjaastad
2017-04-20 13:40:56 +02:00
parent a7ac9f89ec bd47826608
commit c35e79c3b5
3055 changed files with 298219 additions and 130262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
ApplicationCode/ProjectDataModel/CMakeLists_files.cmake
View File

@@ -81,7 +81,6 @@ ${CEE_CURRENT_LIST_DIR}RimIntersectionCollection.h
${CEE_CURRENT_LIST_DIR}RimContextCommandBuilder.h
${CEE_CURRENT_LIST_DIR}RimGridCollection.h
${CEE_CURRENT_LIST_DIR}RimPlotCurve.h
${CEE_CURRENT_LIST_DIR}RimEclipseInputCaseOpm.h
${CEE_CURRENT_LIST_DIR}RimIntersectionBox.h
${CEE_CURRENT_LIST_DIR}RimMultiSnapshotDefinition.h
${CEE_CURRENT_LIST_DIR}RimMdiWindowController.h
@@ -89,8 +88,8 @@ ${CEE_CURRENT_LIST_DIR}RimPropertyFilter.h
${CEE_CURRENT_LIST_DIR}RimNamedObject.h
${CEE_CURRENT_LIST_DIR}RimCheckableNamedObject.h
${CEE_CURRENT_LIST_DIR}RimGridTimeHistoryCurve.h
${CEE_CURRENT_LIST_DIR}RimPickingTopologyItem.h
${CEE_CURRENT_LIST_DIR}RimEclipseTopologyItem.h
${CEE_CURRENT_LIST_DIR}RimGeometrySelectionItem.h
${CEE_CURRENT_LIST_DIR}RimEclipseGeometrySelectionItem.h
${CEE_CURRENT_LIST_DIR}RimEllipseFractureTemplate.h
${CEE_CURRENT_LIST_DIR}RimFractureTemplateCollection.h
${CEE_CURRENT_LIST_DIR}RimFracture.h
@@ -182,7 +181,6 @@ ${CEE_CURRENT_LIST_DIR}RimIntersectionCollection.cpp
${CEE_CURRENT_LIST_DIR}RimContextCommandBuilder.cpp
${CEE_CURRENT_LIST_DIR}RimGridCollection.cpp
${CEE_CURRENT_LIST_DIR}RimPlotCurve.cpp
${CEE_CURRENT_LIST_DIR}RimEclipseInputCaseOpm.cpp
${CEE_CURRENT_LIST_DIR}RimIntersectionBox.cpp
${CEE_CURRENT_LIST_DIR}RimMultiSnapshotDefinition.cpp
${CEE_CURRENT_LIST_DIR}RimMdiWindowController.cpp
@@ -190,8 +188,8 @@ ${CEE_CURRENT_LIST_DIR}RimPropertyFilter.cpp
${CEE_CURRENT_LIST_DIR}RimNamedObject.cpp
${CEE_CURRENT_LIST_DIR}RimCheckableNamedObject.cpp
${CEE_CURRENT_LIST_DIR}RimGridTimeHistoryCurve.cpp
${CEE_CURRENT_LIST_DIR}RimPickingTopologyItem.cpp
${CEE_CURRENT_LIST_DIR}RimEclipseTopologyItem.cpp
${CEE_CURRENT_LIST_DIR}RimGeometrySelectionItem.cpp
${CEE_CURRENT_LIST_DIR}RimEclipseGeometrySelectionItem.cpp
${CEE_CURRENT_LIST_DIR}RimEllipseFractureTemplate.cpp
${CEE_CURRENT_LIST_DIR}RimFractureTemplateCollection.cpp
${CEE_CURRENT_LIST_DIR}RimFracture.cpp

9
ApplicationCode/ProjectDataModel/Flow/RimFlowCharacteristicsPlot.cpp
View File

@@ -52,6 +52,8 @@ RimFlowCharacteristicsPlot::RimFlowCharacteristicsPlot()
CAF_PDM_InitFieldNoDefault(&m_case, "FlowCase", "Case", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_flowDiagSolution, "FlowDiagSolution", "Flow Diag Solution", "", "", "");
m_flowDiagSolution.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_timeStepSelectionType, "TimeSelectionType", "Time Steps", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_selectedTimeSteps, "SelectedTimeSteps", "", "", "", "");
@@ -138,7 +140,10 @@ QList<caf::PdmOptionItemInfo> RimFlowCharacteristicsPlot::calculateValueOptions(
for ( RimEclipseResultCase* c : cases )
{
options.push_back(caf::PdmOptionItemInfo(c->caseUserDescription(), c, false, c->uiIcon()));
if ( c->defaultFlowDiagSolution() )
{
options.push_back(caf::PdmOptionItemInfo(c->caseUserDescription(), c, false, c->uiIcon()));
}
}
}
}
@@ -148,9 +153,9 @@ QList<caf::PdmOptionItemInfo> RimFlowCharacteristicsPlot::calculateValueOptions(
{
std::vector<RimFlowDiagSolution*> flowSols = m_case->flowDiagSolutions();
options.push_back(caf::PdmOptionItemInfo("None", nullptr));
for ( RimFlowDiagSolution* flowSol : flowSols )
{
options.push_back(caf::PdmOptionItemInfo("None", nullptr));
options.push_back(caf::PdmOptionItemInfo(flowSol->userDescription(), flowSol, false, flowSol->uiIcon()));
}
}

40
ApplicationCode/ProjectDataModel/Flow/RimFlowDiagSolution.cpp
View File

@@ -317,44 +317,20 @@ RimFlowDiagSolution::TracerStatusType RimFlowDiagSolution::tracerStatusInTimeSte
//--------------------------------------------------------------------------------------------------
cvf::Color3f RimFlowDiagSolution::tracerColor(const QString& tracerName) const
{
RimEclipseResultCase* eclCase;
this->firstAncestorOrThisOfType(eclCase);
QString wellName = removeCrossFlowEnding(tracerName);
if ( eclCase )
{
RimEclipseView* activeView = dynamic_cast<RimEclipseView*>(RiaApplication::instance()->activeReservoirView());
if (activeView)
{
RimEclipseWell* well = activeView->wellCollection->findWell(wellName);
if (well)
{
return well->wellPipeColor();
}
}
else
{
// If we do not find a well color, use index in well result data to be able to get variation of tracer colors
// This can be the case if we do not have any views at all
const cvf::Collection<RigSingleWellResultsData>& wellResults = eclCase->eclipseCaseData()->wellResults();
for ( size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx )
{
if ( wellResults[wIdx]->m_wellName == wellName )
{
return RiaColorTables::wellsPaletteColors().cycledColor3f(wIdx);
}
}
}
}
if (wellName == RIG_FLOW_TOTAL_NAME) return cvf::Color3f::LIGHT_GRAY;
if (wellName == RIG_RESERVOIR_TRACER_NAME) return cvf::Color3f::LIGHT_GRAY;
if (wellName == RIG_TINY_TRACER_GROUP_NAME) return cvf::Color3f::DARK_GRAY;
RimEclipseResultCase* eclCase;
this->firstAncestorOrThisOfType(eclCase);
if ( eclCase )
{
return eclCase->defaultWellColor(wellName);
}
return cvf::Color3f::LIGHT_GRAY;
}

4
ApplicationCode/ProjectDataModel/Flow/RimFlowPlotCollection.cpp
View File

@@ -37,10 +37,10 @@ RimFlowPlotCollection::RimFlowPlotCollection()
CAF_PDM_InitFieldNoDefault(&m_flowCharacteristicsPlot, "FlowCharacteristicsPlot", "", "", "", "");
m_flowCharacteristicsPlot.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_defaultWellAllocPlot, "DefaultFlowPlot", "", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_defaultWellAllocPlot, "DefaultWellAllocationPlot", "", "", "", "");
m_defaultWellAllocPlot.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_storedWellAllocPlots, "FlowPlots", "Stored Plots", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_storedWellAllocPlots, "StoredWellAllocationPlots", "Stored Plots", "", "", "");
}
//--------------------------------------------------------------------------------------------------

22
ApplicationCode/ProjectDataModel/Flow/RimTotalWellAllocationPlot.cpp
View File

@@ -138,6 +138,24 @@ QString RimTotalWellAllocationPlot::description() const
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimTotalWellAllocationPlot::totalAllocationAsText() const
{
QString txt;
for (auto a : m_sliceInfo)
{
txt += a.first;
txt += "\t";
txt += QString::number(a.second);
txt += "\n";
}
return txt;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -150,6 +168,8 @@ void RimTotalWellAllocationPlot::addSlice(const QString& name, const cvf::Color3
m_wellTotalAllocationPlotWidget->addItem(name, sliceColor, value);
m_wellTotalAllocationPlotWidget->update();
}
m_sliceInfo.push_back(std::make_pair(name, value));
}
@@ -163,6 +183,8 @@ void RimTotalWellAllocationPlot::clearSlices()
m_wellTotalAllocationPlotWidget->clear();
m_wellTotalAllocationPlotWidget->update();
}
m_sliceInfo.clear();
}
//--------------------------------------------------------------------------------------------------

5
ApplicationCode/ProjectDataModel/Flow/RimTotalWellAllocationPlot.h
View File

@@ -27,6 +27,8 @@
#include <QPointer>
#include <vector>
class RiuWellAllocationPlot;
class RimEclipseWell;
class RimWellLogPlot;
@@ -55,6 +57,7 @@ public:
void setDescription(const QString& description);
QString description() const;
QString totalAllocationAsText() const;
void addSlice(const QString& name, const cvf::Color3f& color, float value);
void clearSlices();
@@ -80,4 +83,6 @@ private:
caf::PdmField<QString> m_userName;
QPointer<RiuNightchartsWidget> m_wellTotalAllocationPlotWidget;
std::vector<std::pair<QString, float> > m_sliceInfo;
};

105
ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp
View File

@@ -80,15 +80,13 @@ RimWellAllocationPlot::RimWellAllocationPlot()
CAF_PDM_InitFieldNoDefault(&m_case, "CurveCase", "Case", "", "", "");
m_case.uiCapability()->setUiTreeChildrenHidden(true);
CAF_PDM_InitField(&m_timeStep, "PlotTimeStep", 0, "Time Step", "", "", "");
CAF_PDM_InitField(&m_wellName, "WellName", QString("None"), "Well", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_flowDiagSolution, "FlowDiagSolution", "Flow Diag Solution", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_flowType, "FlowType", "Flow Type", "", "", "");
CAF_PDM_InitField(&m_groupSmallContributions, "GroupSmallContributions", true, "Group Small Contributions", "", "", "");
CAF_PDM_InitField(&m_smallContributionsThreshold, "SmallContributionsThreshold", 0.005, "Threshold", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_accumulatedWellFlowPlot, "AccumulatedWellFlowPlot", "Accumulated Well Flow", "", "", "");
CAF_PDM_InitField(&m_timeStep, "PlotTimeStep", 0, "Time Step", "", "", "");
CAF_PDM_InitField(&m_wellName, "WellName", QString("None"), "Well", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_flowDiagSolution, "FlowDiagSolution", "Plot Type", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_flowType, "FlowType", "Flow Type", "", "", "");
CAF_PDM_InitField(&m_groupSmallContributions, "GroupSmallContributions", true, "Group Small Contributions", "", "", "");
CAF_PDM_InitField(&m_smallContributionsThreshold, "SmallContributionsThreshold", 0.005, "Threshold", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_accumulatedWellFlowPlot, "AccumulatedWellFlowPlot", "Accumulated Well Flow", "", "", "");
m_accumulatedWellFlowPlot.uiCapability()->setUiHidden(true);
m_accumulatedWellFlowPlot = new RimWellLogPlot;
m_accumulatedWellFlowPlot->setDepthUnit(RimDefines::UNIT_NONE);
@@ -515,6 +513,14 @@ RimTotalWellAllocationPlot* RimWellAllocationPlot::totalWellFlowPlot()
return m_totalWellAllocationPlot();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
caf::PdmObject* RimWellAllocationPlot::plotLegend()
{
return m_wellAllocationPlotLegend;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -540,16 +546,7 @@ QList<caf::PdmOptionItemInfo> RimWellAllocationPlot::calculateValueOptions(const
if (fieldNeedingOptions == &m_wellName)
{
std::set<QString> sortedWellNames;
if ( m_case && m_case->eclipseCaseData() )
{
const cvf::Collection<RigSingleWellResultsData>& wellRes = m_case->eclipseCaseData()->wellResults();
for ( size_t wIdx = 0; wIdx < wellRes.size(); ++wIdx )
{
sortedWellNames.insert(wellRes[wIdx]->m_wellName);
}
}
std::set<QString> sortedWellNames = this->findSortedWellNames();
QIcon simWellIcon(":/Well.png");
for ( const QString& wname: sortedWellNames )
@@ -595,12 +592,18 @@ QList<caf::PdmOptionItemInfo> RimWellAllocationPlot::calculateValueOptions(const
{
if (m_case)
{
std::vector<RimFlowDiagSolution*> flowSols = m_case->flowDiagSolutions();
//std::vector<RimFlowDiagSolution*> flowSols = m_case->flowDiagSolutions();
// options.push_back(caf::PdmOptionItemInfo("None", nullptr));
//for (RimFlowDiagSolution* flowSol : flowSols)
//{
// options.push_back(caf::PdmOptionItemInfo(flowSol->userDescription(), flowSol, false, flowSol->uiIcon()));
//}
for (RimFlowDiagSolution* flowSol : flowSols)
RimFlowDiagSolution* defaultFlowSolution = m_case->defaultFlowDiagSolution();
options.push_back(caf::PdmOptionItemInfo("Well Flow", nullptr));
if (defaultFlowSolution)
{
options.push_back(caf::PdmOptionItemInfo("None", nullptr));
options.push_back(caf::PdmOptionItemInfo(flowSol->userDescription(), flowSol, false, flowSol->uiIcon()));
options.push_back(caf::PdmOptionItemInfo("Allocation", defaultFlowSolution ));
}
}
}
@@ -645,8 +648,30 @@ void RimWellAllocationPlot::fieldChangedByUi(const caf::PdmFieldHandle* changedF
{
updateWidgetTitleWindowTitle();
}
else if ( changedField == &m_case)
{
if ( m_flowDiagSolution && m_case )
{
m_flowDiagSolution = m_case->defaultFlowDiagSolution();
}
else
{
m_flowDiagSolution = nullptr;
}
if (!m_case) m_timeStep = 0;
else if (m_timeStep >= static_cast<int>(m_case->timeStepDates().size()))
{
m_timeStep = std::max(0, ((int)m_case->timeStepDates().size()) - 1);
}
std::set<QString> sortedWellNames = findSortedWellNames();
if (!sortedWellNames.size()) m_wellName = "";
else if ( sortedWellNames.count(m_wellName()) == 0 ){ m_wellName = *sortedWellNames.begin();}
loadDataAndUpdate();
}
else if ( changedField == &m_wellName
|| changedField == &m_case
|| changedField == &m_timeStep
|| changedField == &m_flowDiagSolution
|| changedField == &m_groupSmallContributions
@@ -657,6 +682,25 @@ void RimWellAllocationPlot::fieldChangedByUi(const caf::PdmFieldHandle* changedF
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<QString> RimWellAllocationPlot::findSortedWellNames()
{
std::set<QString> sortedWellNames;
if ( m_case && m_case->eclipseCaseData() )
{
const cvf::Collection<RigSingleWellResultsData>& wellRes = m_case->eclipseCaseData()->wellResults();
for ( size_t wIdx = 0; wIdx < wellRes.size(); ++wIdx )
{
sortedWellNames.insert(wellRes[wIdx]->m_wellName);
}
}
return sortedWellNames;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -678,6 +722,19 @@ QImage RimWellAllocationPlot::snapshotWindowContent()
//--------------------------------------------------------------------------------------------------
void RimWellAllocationPlot::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
uiOrdering.add(&m_userName);
uiOrdering.add(&m_showPlotTitle);
caf::PdmUiGroup& dataGroup = *uiOrdering.addNewGroup("Plot Data");
dataGroup.add(&m_case);
dataGroup.add(&m_timeStep);
dataGroup.add(&m_wellName);
caf::PdmUiGroup& optionGroup = *uiOrdering.addNewGroup("Options");
optionGroup.add(&m_flowDiagSolution);
optionGroup.add(&m_flowType);
optionGroup.add(&m_groupSmallContributions);
optionGroup.add(&m_smallContributionsThreshold);
m_smallContributionsThreshold.uiCapability()->setUiReadOnly(!m_groupSmallContributions());
}

4
ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.h
View File

@@ -68,6 +68,7 @@ public:
RimWellLogPlot* accumulatedWellFlowPlot();
RimTotalWellAllocationPlot* totalWellFlowPlot();
caf::PdmObject* plotLegend();
RimFlowDiagSolution* flowDiagSolution();
int timeStep();
@@ -80,6 +81,9 @@ protected:
// Overridden PDM methods
virtual caf::PdmFieldHandle* userDescriptionField() { return &m_userName; }
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
std::set<QString> findSortedWellNames();
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;
virtual QImage snapshotWindowContent() override;

15
ApplicationCode/ProjectDataModel/Flow/RimWellFlowRateCurve.cpp
View File

@@ -40,7 +40,7 @@
///
//==================================================================================================
CAF_PDM_SOURCE_INIT(RimWellFlowRateCurve, "RimWellFlowRateCurve");
CAF_PDM_SOURCE_INIT(RimWellFlowRateCurve, "WellFlowRateCurve");
//--------------------------------------------------------------------------------------------------
///
@@ -149,6 +149,19 @@ void RimWellFlowRateCurve::updateCurveAppearance()
m_qwtPlotCurve->setCurveAttribute(QwtPlotCurve::Inverted, true);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellFlowRateCurve::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
uiOrdering.add(&m_curveName);
m_curveName.uiCapability()->setUiReadOnly(true);
uiOrdering.add(&m_curveColor);
m_curveColor.uiCapability()->setUiReadOnly(true);
uiOrdering.skipRemainingFields();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/ProjectDataModel/Flow/RimWellFlowRateCurve.h
View File

@@ -49,6 +49,8 @@ protected:
virtual void onLoadDataAndUpdate() override;
virtual void updateCurveAppearance() override;
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
private:
bool isUsingConnectionNumberDepthType() const;
RimWellAllocationPlot* wellAllocationPlot() const;

2
ApplicationCode/ProjectDataModel/RimCase.cpp
View File

@@ -39,7 +39,7 @@ CAF_PDM_XML_ABSTRACT_SOURCE_INIT(RimCase, "RimCase");
//--------------------------------------------------------------------------------------------------
RimCase::RimCase()
{
CAF_PDM_InitField(&caseUserDescription, "CaseUserDescription", QString(), "Case name", "", "" ,"");
CAF_PDM_InitField(&caseUserDescription, "CaseUserDescription", QString(), "Case Name", "", "" ,"");
CAF_PDM_InitField(&caseId, "CaseId", -1, "Case ID", "", "" ,"");
caseId.uiCapability()->setUiReadOnly(true);

3
ApplicationCode/ProjectDataModel/RimCase.h
View File

@@ -61,8 +61,9 @@ public:
virtual void updateFormationNamesData() = 0;
private:
protected:
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;
private:
virtual caf::PdmFieldHandle* userDescriptionField() override { return &caseUserDescription; }
};

3
ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@@ -172,7 +172,6 @@ QStringList RimContextCommandBuilder::commandsFromSelection()
else if (dynamic_cast<RimEclipseInputPropertyCollection*>(uiItem))
{
commandIds << "RicAddEclipseInputPropertyFeature";
commandIds << "RicAddOpmInputPropertyFeature";
}
else if (dynamic_cast<RimEclipseInputProperty*>(uiItem))
{
@@ -429,6 +428,8 @@ QStringList RimContextCommandBuilder::commandsFromSelection()
commandIds << "RicCopyReferencesToClipboardFeature";
commandIds << "RicShowPlotDataFeature";
commandIds << "RicShowTotalAllocationDataFeature";
commandIds << "RicSummaryCurveSwitchAxisFeature";
// Work in progress -- End

73
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@@ -21,12 +21,14 @@
#include "RimEclipseCase.h"
#include "RiaApplication.h"
#include "RiaColorTables.h"
#include "RiaPreferences.h"
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RigSingleWellResultsData.h"
#include "RimCaseCollection.h"
#include "RimCellEdgeColors.h"
@@ -133,6 +135,48 @@ const RigEclipseCaseData* RimEclipseCase::eclipseCaseData() const
return m_rigEclipseCase.p();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Color3f RimEclipseCase::defaultWellColor(const QString& wellName)
{
if ( m_wellToColorMap.empty() )
{
const caf::ColorTable& colorTable = RiaColorTables::wellsPaletteColors();
cvf::Color3ubArray wellColors = colorTable.color3ubArray();
cvf::Color3ubArray interpolatedWellColors = wellColors;
const cvf::Collection<RigSingleWellResultsData>& wellResults = this->eclipseCaseData()->wellResults();
if ( wellResults.size() > 1 )
{
interpolatedWellColors = caf::ColorTable::interpolateColorArray(wellColors, wellResults.size());
}
for ( size_t wIdx = 0; wIdx < wellResults.size(); ++wIdx )
{
m_wellToColorMap[wellResults[wIdx]->m_wellName] = cvf::Color3f::BLACK;
}
size_t wIdx = 0;
for ( auto & wNameColorPair: m_wellToColorMap )
{
wNameColorPair.second = cvf::Color3f(interpolatedWellColors[wIdx]);
++wIdx;
}
}
auto nmColor = m_wellToColorMap.find(wellName);
if (nmColor != m_wellToColorMap.end())
{
return nmColor->second;
}
else
{
return cvf::Color3f::LIGHT_GRAY;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -190,10 +234,8 @@ RimEclipseView* RimEclipseCase::createCopyAndAddView(const RimEclipseView* sourc
reservoirViews().push_back(rimEclipseView);
// Resolve references after reservoir view has been inserted into Rim structures
// Intersections referencing a well path/ simulation well requires this
// TODO: initAfterReadRecursively can probably be removed
rimEclipseView->initAfterReadRecursively();
rimEclipseView->resolveReferencesRecursively();
rimEclipseView->initAfterReadRecursively();
return rimEclipseView;
}
@@ -573,28 +615,47 @@ QStringList RimEclipseCase::timeStepStrings()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimEclipseCase::timeStepName(int frameIdx)
{
std::vector<QDateTime> timeStepDates = this->timeStepDates();
CVF_ASSERT(frameIdx < timeStepDates.size());
CVF_ASSERT(frameIdx < static_cast<int>(timeStepDates.size()));
if (m_timeStepFormatString.isEmpty())
{
bool hasHoursAndMinutesInTimesteps = false;
bool hasSecondsInTimesteps = false;
bool hasMillisecondsInTimesteps = false;
for (size_t i = 0; i < timeStepDates.size(); i++)
{
if (timeStepDates[i].time().hour() != 0.0 || timeStepDates[i].time().minute() != 0.0)
if (timeStepDates[i].time().msec() != 0.0)
{
hasMillisecondsInTimesteps = true;
hasSecondsInTimesteps = true;
hasHoursAndMinutesInTimesteps = true;
break;
}
else if (timeStepDates[i].time().second() != 0.0) {
hasHoursAndMinutesInTimesteps = true;
hasSecondsInTimesteps = true;
}
else if (timeStepDates[i].time().hour() != 0.0 || timeStepDates[i].time().minute() != 0.0)
{
hasHoursAndMinutesInTimesteps = true;
}
}
m_timeStepFormatString = "dd.MMM yyyy";
if (hasHoursAndMinutesInTimesteps)
{
m_timeStepFormatString += " - hh:mm";
if (hasSecondsInTimesteps)
{
m_timeStepFormatString += ":ss";
if (hasMillisecondsInTimesteps)
{
m_timeStepFormatString += ".zzz";
}
}
}
}

6
ApplicationCode/ProjectDataModel/RimEclipseCase.h
View File

@@ -31,6 +31,7 @@
#include "cvfBase.h"
#include "cvfObject.h"
#include "cvfColor3.h"
class QString;
@@ -69,6 +70,7 @@ public:
RigEclipseCaseData* eclipseCaseData();
const RigEclipseCaseData* eclipseCaseData() const;
cvf::Color3f defaultWellColor(const QString& wellName);
RimReservoirCellResultsStorage* results(RifReaderInterface::PorosityModelResultType porosityModel);
@@ -108,13 +110,15 @@ protected:
void setReservoirData(RigEclipseCaseData* eclipseCase);
private:
cvf::ref<RigEclipseCaseData> m_rigEclipseCase;
cvf::ref<RigEclipseCaseData> m_rigEclipseCase;
private:
caf::PdmChildField<RimReservoirCellResultsStorage*> m_matrixModelResults;
caf::PdmChildField<RimReservoirCellResultsStorage*> m_fractureModelResults;
QString m_timeStepFormatString;
std::map<QString , cvf::Color3f> m_wellToColorMap;
// Obsolete fields
protected:
caf::PdmField<QString> caseName;

31
ApplicationCode/ProjectDataModel/RimEclipseTopologyItem.cpp → ApplicationCode/ProjectDataModel/RimEclipseGeometrySelectionItem.cpp
View File

@@ -16,7 +16,7 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimEclipseTopologyItem.h"
#include "RimEclipseGeometrySelectionItem.h"
#include "RigTimeHistoryResultAccessor.h"
@@ -26,34 +26,33 @@
#include "RiuSelectionManager.h"
CAF_PDM_SOURCE_INIT(RimEclipseTopologyItem, "RimEclipseTopologyItem");
CAF_PDM_SOURCE_INIT(RimEclipseGeometrySelectionItem, "EclipseGeometrySelectionItem");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseTopologyItem::RimEclipseTopologyItem()
RimEclipseGeometrySelectionItem::RimEclipseGeometrySelectionItem()
{
CAF_PDM_InitObject("Eclipse Topoloty Item", "", "", "");
CAF_PDM_InitObject("Eclipse Geometry Selection Item", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_eclipseCase, "EclipseCase", "Eclipse Case", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_gridIndex, "m_gridIndex", "m_gridIndex", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_cellIndex, "m_cellIndex", "m_cellIndex", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_localIntersectionPoint, "m_localIntersectionPoint", "m_localIntersectionPoint", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_eclipseCase, "EclipseCase", "Eclipse Case", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_gridIndex, "GridIndex", "m_gridIndex", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_cellIndex, "CellIndex", "m_cellIndex", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_localIntersectionPoint, "LocalIntersectionPoint", "m_localIntersectionPoint", "", "", "");
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseTopologyItem::~RimEclipseTopologyItem()
RimEclipseGeometrySelectionItem::~RimEclipseGeometrySelectionItem()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseTopologyItem::setFromSelectionItem(const RiuEclipseSelectionItem* selectionItem)
void RimEclipseGeometrySelectionItem::setFromSelectionItem(const RiuEclipseSelectionItem* selectionItem)
{
m_gridIndex = selectionItem->m_gridIndex;
m_cellIndex = selectionItem->m_cellIndex;
@@ -65,7 +64,7 @@ void RimEclipseTopologyItem::setFromSelectionItem(const RiuEclipseSelectionItem*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimEclipseTopologyItem::topologyText() const
QString RimEclipseGeometrySelectionItem::geometrySelectionText() const
{
QString text;
@@ -81,7 +80,7 @@ QString RimEclipseTopologyItem::topologyText() const
text += ", ";
text += QString("Grid index %1").arg(m_gridIndex);
text += ", ";
text += RigTimeHistoryResultAccessor::topologyText(m_eclipseCase->eclipseCaseData(), m_gridIndex, m_cellIndex);
text += RigTimeHistoryResultAccessor::geometrySelectionText(m_eclipseCase->eclipseCaseData(), m_gridIndex, m_cellIndex);
return text;
}
@@ -89,7 +88,7 @@ QString RimEclipseTopologyItem::topologyText() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseCase* RimEclipseTopologyItem::eclipseCase() const
RimEclipseCase* RimEclipseGeometrySelectionItem::eclipseCase() const
{
return m_eclipseCase;
}
@@ -97,7 +96,7 @@ RimEclipseCase* RimEclipseTopologyItem::eclipseCase() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RimEclipseTopologyItem::gridIndex() const
size_t RimEclipseGeometrySelectionItem::gridIndex() const
{
return m_gridIndex;
}
@@ -105,7 +104,7 @@ size_t RimEclipseTopologyItem::gridIndex() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RimEclipseTopologyItem::cellIndex() const
size_t RimEclipseGeometrySelectionItem::cellIndex() const
{
return m_cellIndex;
}

10
ApplicationCode/ProjectDataModel/RimEclipseTopologyItem.h → ApplicationCode/ProjectDataModel/RimEclipseGeometrySelectionItem.h
View File

@@ -18,7 +18,7 @@
#pragma once
#include "RimPickingTopologyItem.h"
#include "RimGeometrySelectionItem.h"
#include "cafPdmField.h"
#include "cafPdmFieldCvfVec3d.h"
@@ -31,16 +31,16 @@ class RiuEclipseSelectionItem;
///
///
//==================================================================================================
class RimEclipseTopologyItem : public RimPickingTopologyItem
class RimEclipseGeometrySelectionItem : public RimGeometrySelectionItem
{
CAF_PDM_HEADER_INIT;
public:
RimEclipseTopologyItem();
virtual ~RimEclipseTopologyItem() override;
RimEclipseGeometrySelectionItem();
virtual ~RimEclipseGeometrySelectionItem() override;
void setFromSelectionItem(const RiuEclipseSelectionItem* selectionItem);
virtual QString topologyText() const override;
virtual QString geometrySelectionText() const override;
RimEclipseCase* eclipseCase() const;
size_t gridIndex() const;

19
ApplicationCode/ProjectDataModel/RimEclipseInputCase.cpp
View File

@@ -51,7 +51,7 @@ RimEclipseInputCase::RimEclipseInputCase()
: RimEclipseCase()
{
CAF_PDM_InitObject("RimInputCase", ":/EclipseInput48x48.png", "", "");
CAF_PDM_InitField(&m_gridFileName, "GridFileName", QString(), "Case grid filename", "", "" ,"");
CAF_PDM_InitField(&m_gridFileName, "GridFileName", QString(), "Case File Name", "", "" ,"");
m_gridFileName.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitFieldNoDefault(&m_additionalFileNames, "AdditionalFileNames", "Additional files", "", "" ,"");
m_additionalFileNames.uiCapability()->setUiReadOnly(true);
@@ -375,6 +375,23 @@ cvf::ref<RifReaderInterface> RimEclipseInputCase::createMockModel(QString modelN
return mockFileInterface.p();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseInputCase::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
uiOrdering.add(&caseUserDescription);
uiOrdering.add(&caseId);
uiOrdering.add(&m_gridFileName);
uiOrdering.add(&m_additionalFileNames);
auto group = uiOrdering.addNewGroup("Case Options");
group->add(&activeFormationNames);
group->add(&flipXAxis);
group->add(&flipYAxis);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

3
ApplicationCode/ProjectDataModel/RimEclipseInputCase.h
View File

@@ -60,6 +60,9 @@ public:
virtual void updateFilePathsFromProjectPath(const QString& projectPath, const QString& oldProjectPath);
protected:
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
private:
cvf::ref<RifReaderInterface> createMockModel(QString modelName);

269
ApplicationCode/ProjectDataModel/RimEclipseInputCaseOpm.cpp
View File

@@ -1,269 +0,0 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2016 Statoil ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimEclipseInputCaseOpm.h"
#include "RiaApplication.h"
#include "RiaPreferences.h"
#include "RifReaderOpmParserInput.h"
#include "RifReaderSettings.h"
#include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RimEclipseCase.h"
#include "RimEclipseInputProperty.h"
#include "RimEclipseInputPropertyCollection.h"
#include "RimReservoirCellResultsStorage.h"
#include "RimTools.h"
#include "cafProgressInfo.h"
#include <QFileInfo>
CAF_PDM_SOURCE_INIT(RimEclipseInputCaseOpm, "EclipseInputCaseOpm");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseInputCaseOpm::RimEclipseInputCaseOpm()
: RimEclipseCase()
{
CAF_PDM_InitObject("RimInputCase", ":/EclipseInput48x48.png", "", "");
CAF_PDM_InitField(&m_gridFileName, "GridFileName", QString(), "Case grid filename", "", "" ,"");
m_gridFileName.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitFieldNoDefault(&m_additionalFileNames, "AdditionalFileNames", "Additional files", "", "", "");
m_additionalFileNames.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitFieldNoDefault(&m_inputPropertyCollection, "InputPropertyCollection", "", "", "", "");
m_inputPropertyCollection = new RimEclipseInputPropertyCollection;
m_inputPropertyCollection->parentField()->uiCapability()->setUiHidden(true);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseInputCaseOpm::~RimEclipseInputCaseOpm()
{
delete m_inputPropertyCollection;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseInputCaseOpm::importNewEclipseGridAndProperties(const QString& fileName)
{
m_gridFileName = fileName;
QFileInfo gridFileName(m_gridFileName);
QString caseName = gridFileName.completeBaseName();
this->caseUserDescription = caseName + " (opm-parser)";
importEclipseGridAndProperties(m_gridFileName);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseInputCaseOpm::appendPropertiesFromStandaloneFiles(const QStringList& fileNames)
{
for (auto filename : fileNames)
{
QFileInfo fi(filename);
if (!fi.exists()) continue;
RifReaderOpmParserPropertyReader propertyReader(filename);
std::set<std::string> fileKeywordSet = propertyReader.keywords();
std::vector<std::string> knownKeywords = RifReaderOpmParserInput::knownPropertyKeywords();
for (auto knownKeyword : knownKeywords)
{
if (fileKeywordSet.count(knownKeyword) > 0)
{
QString qtKnownKeyword = QString::fromStdString(knownKeyword);
QString resultName = this->eclipseCaseData()->results(RifReaderInterface::MATRIX_RESULTS)->makeResultNameUnique(qtKnownKeyword);
if (propertyReader.copyPropertyToCaseData(knownKeyword, this->eclipseCaseData(), resultName))
{
RimEclipseInputProperty* inputProperty = new RimEclipseInputProperty;
inputProperty->resultName = resultName;
inputProperty->eclipseKeyword = qtKnownKeyword;
inputProperty->fileName = filename;
inputProperty->resolvedState = RimEclipseInputProperty::RESOLVED;
m_inputPropertyCollection->inputProperties.push_back(inputProperty);
}
}
}
m_additionalFileNames.v().push_back(filename);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimEclipseInputCaseOpm::openEclipseGridFile()
{
importEclipseGridAndProperties(m_gridFileName);
loadAndSyncronizeInputProperties();
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimEclipseInputCaseOpm::locationOnDisc() const
{
if (m_gridFileName().isEmpty()) return QString();
QFileInfo fi(m_gridFileName);
return fi.absolutePath();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseInputCaseOpm::updateFilePathsFromProjectPath(const QString& newProjectPath, const QString& oldProjectPath)
{
bool foundFile = false;
std::vector<QString> searchedPaths;
m_gridFileName = RimTools::relocateFile(m_gridFileName(), newProjectPath, oldProjectPath, &foundFile, &searchedPaths);
for (size_t i = 0; i < m_additionalFileNames().size(); i++)
{
m_additionalFileNames.v()[i] = RimTools::relocateFile(m_additionalFileNames()[i], newProjectPath, oldProjectPath, &foundFile, &searchedPaths);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseInputCaseOpm::importEclipseGridAndProperties(const QString& fileName)
{
if (this->eclipseCaseData() == NULL)
{
this->setReservoirData(new RigEclipseCaseData);
RifReaderOpmParserInput::importGridPropertiesFaults(fileName, eclipseCaseData());
if (this->eclipseCaseData()->mainGrid() == NULL)
{
return;
}
this->eclipseCaseData()->mainGrid()->setFlipAxis(flipXAxis, flipYAxis);
computeCachedData();
RiaApplication* app = RiaApplication::instance();
if (app->preferences()->autocomputeDepthRelatedProperties)
{
RimReservoirCellResultsStorage* matrixResults = results(RifReaderInterface::MATRIX_RESULTS);
RimReservoirCellResultsStorage* fractureResults = results(RifReaderInterface::FRACTURE_RESULTS);
matrixResults->computeDepthRelatedResults();
fractureResults->computeDepthRelatedResults();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimEclipseInputCaseOpm::loadAndSyncronizeInputProperties()
{
// Make sure we actually have reservoir data
CVF_ASSERT(this->eclipseCaseData());
CVF_ASSERT(this->eclipseCaseData()->mainGrid()->gridPointDimensions() != cvf::Vec3st(0, 0, 0));
// Then read the properties from all the files referenced by the InputReservoir
for (QString filename : m_additionalFileNames())
{
QFileInfo fileNameInfo(filename);
bool isExistingFile = fileNameInfo.exists();
// Find the input property objects referring to the file
std::vector<RimEclipseInputProperty*> ipsUsingThisFile = this->m_inputPropertyCollection()->findInputProperties(filename);
if (!isExistingFile)
{
for (auto inputProperty : ipsUsingThisFile)
{
inputProperty->resolvedState = RimEclipseInputProperty::FILE_MISSING;
}
}
else
{
RifReaderOpmParserPropertyReader propertyReader(filename);
std::set<std::string> fileKeywordSet = propertyReader.keywords();
for (auto inputProperty : ipsUsingThisFile)
{
QString kw = inputProperty->eclipseKeyword();
inputProperty->resolvedState = RimEclipseInputProperty::KEYWORD_NOT_IN_FILE;
if (fileKeywordSet.count(kw.toStdString()))
{
if (propertyReader.copyPropertyToCaseData(kw.toStdString(), this->eclipseCaseData(), inputProperty->resultName))
{
inputProperty->resolvedState = RimEclipseInputProperty::RESOLVED;
}
}
fileKeywordSet.erase(kw.toStdString());
}
if (!fileKeywordSet.empty())
{
std::vector<std::string> knownKeywords = RifReaderOpmParserInput::knownPropertyKeywords();
for (auto knownKeyword : knownKeywords)
{
if (fileKeywordSet.count(knownKeyword) > 0)
{
QString qtKnownKeyword = QString::fromStdString(knownKeyword);
QString resultName = this->eclipseCaseData()->results(RifReaderInterface::MATRIX_RESULTS)->makeResultNameUnique(qtKnownKeyword);
if (propertyReader.copyPropertyToCaseData(knownKeyword, this->eclipseCaseData(), resultName))
{
RimEclipseInputProperty* inputProperty = new RimEclipseInputProperty;
inputProperty->resultName = resultName;
inputProperty->eclipseKeyword = qtKnownKeyword;
inputProperty->fileName = filename;
inputProperty->resolvedState = RimEclipseInputProperty::RESOLVED;
m_inputPropertyCollection->inputProperties.push_back(inputProperty);
}
}
}
}
}
}
for(auto inputProperty : m_inputPropertyCollection->inputProperties())
{
if (inputProperty->resolvedState() == RimEclipseInputProperty::UNKNOWN)
{
inputProperty->resolvedState = RimEclipseInputProperty::FILE_MISSING;
}
}
}

69
ApplicationCode/ProjectDataModel/RimEclipseInputCaseOpm.h
View File

@@ -1,69 +0,0 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2016 Statoil ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RimEclipseCase.h"
#include "cafPdmChildField.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cvfBase.h"
#include "cvfObject.h"
class RimEclipseInputProperty;
class RimEclipseInputPropertyCollection;
//==================================================================================================
//
// This class is intended to replace RimEclipseInputCase when the opm-parser is considered stable
//
//==================================================================================================
class RimEclipseInputCaseOpm : public RimEclipseCase
{
CAF_PDM_HEADER_INIT;
public:
RimEclipseInputCaseOpm();
virtual ~RimEclipseInputCaseOpm();
void importNewEclipseGridAndProperties(const QString& fileName);
void appendPropertiesFromStandaloneFiles(const QStringList& fileNames);
// RimCase overrides
virtual bool openEclipseGridFile(); // Find grid file among file set. Read, Find read and validate property date. Syncronize child property sets.
// Overrides from RimCase
virtual QString locationOnDisc() const;
virtual QString gridFileName() const { return m_gridFileName();}
virtual void updateFilePathsFromProjectPath(const QString& projectPath, const QString& oldProjectPath);
private:
void importEclipseGridAndProperties(const QString& fileName);
void loadAndSyncronizeInputProperties();
private:
caf::PdmChildField<RimEclipseInputPropertyCollection*> m_inputPropertyCollection;
caf::PdmField<std::vector<QString> > m_additionalFileNames;
caf::PdmField<QString> m_gridFileName;
};

14
ApplicationCode/ProjectDataModel/RimEclipsePropertyFilter.cpp
View File

@@ -186,24 +186,26 @@ void RimEclipsePropertyFilter::defineUiOrdering(QString uiConfigName, caf::PdmUi
caf::PdmUiGroup* group1 = uiOrdering.addNewGroup("Result");
resultDefinition->uiOrdering(uiConfigName, *group1);
caf::PdmUiGroup& group2 = *(uiOrdering.addNewGroup("Filter Settings"));
// Fields declared in RimCellFilter
uiOrdering.add(&filterMode);
group2.add(&filterMode);
uiOrdering.add(&m_rangeLabelText);
group2.add(&m_rangeLabelText);
if (resultDefinition->hasCategoryResult())
{
uiOrdering.add(&m_useCategorySelection);
group2.add(&m_useCategorySelection);
}
if ( resultDefinition->hasCategoryResult() && m_useCategorySelection() )
{
uiOrdering.add(&m_selectedCategoryValues);
group2.add(&m_selectedCategoryValues);
}
else
{
uiOrdering.add(&m_lowerBound);
uiOrdering.add(&m_upperBound);
group2.add(&m_lowerBound);
group2.add(&m_upperBound);
}
uiOrdering.skipRemainingFields(true);

11
ApplicationCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

@@ -55,10 +55,13 @@ RimEclipseResultCase::RimEclipseResultCase()
{
CAF_PDM_InitObject("Eclipse Case", ":/Case48x48.png", "", "");
CAF_PDM_InitField(&caseFileName, "CaseFileName", QString(), "Case file name", "", "" ,"");
CAF_PDM_InitField(&caseFileName, "CaseFileName", QString(), "Case File Name", "", "" ,"");
caseFileName.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitFieldNoDefault (&m_flowDiagSolutions, "FlowDiagSolutions", "Flow Diagnostics Solutions", "", "", "");
m_flowDiagSolutions.uiCapability()->setUiHidden(true);
m_flowDiagSolutions.uiCapability()->setUiTreeHidden(true);
m_flowDiagSolutions.uiCapability()->setUiTreeChildrenHidden(true);
// Obsolete, unused field
CAF_PDM_InitField(&caseDirectory, "CaseFolder", QString(), "Directory", "", "" ,"");
@@ -432,5 +435,11 @@ void RimEclipseResultCase::defineUiOrdering(QString uiConfigName, caf::PdmUiOrde
uiOrdering.add(&caseUserDescription);
uiOrdering.add(&caseId);
uiOrdering.add(&caseFileName);
auto group = uiOrdering.addNewGroup("Case Options");
group->add(&activeFormationNames);
group->add(&flipXAxis);
group->add(&flipYAxis);
}

5
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@@ -100,7 +100,8 @@ RimEclipseResultDefinition::RimEclipseResultDefinition()
CAF_PDM_InitFieldNoDefault(&m_flowSolutionUiField, "MFlowDiagSolution", "Solution", "", "", "");
m_flowSolutionUiField.xmlCapability()->setIOReadable(false);
m_flowSolutionUiField.xmlCapability()->setIOWritable(false);
m_flowSolutionUiField.uiCapability()->setUiHidden(true); // For now since there are only one to choose from
CAF_PDM_InitFieldNoDefault(&m_selectedTracersUiField, "MSelectedTracers", " ", "", "", "");
m_selectedTracersUiField.xmlCapability()->setIOReadable(false);
m_selectedTracersUiField.xmlCapability()->setIOWritable(false);
@@ -672,7 +673,7 @@ RigFlowDiagResultAddress RimEclipseResultDefinition::flowDiagResAddress() const
}
else
{
RimFlowDiagSolution* flowSol = m_flowSolutionUiField();
RimFlowDiagSolution* flowSol = m_flowSolution();
if (flowSol)
{
std::vector<QString> tracerNames = flowSol->tracerNames();

31
ApplicationCode/ProjectDataModel/RimEclipseStatisticsCase.cpp
View File

@@ -75,7 +75,7 @@ RimEclipseStatisticsCase::RimEclipseStatisticsCase()
m_selectionSummary.xmlCapability()->setIOReadable(false);
m_selectionSummary.uiCapability()->setUiReadOnly(true);
m_selectionSummary.uiCapability()->setUiEditorTypeName(caf::PdmUiTextEditor::uiEditorTypeName());
m_selectionSummary.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::TOP);
m_selectionSummary.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
CAF_PDM_InitFieldNoDefault(&m_resultType, "ResultType", "Result Type", "", "", "");
m_resultType.xmlCapability()->setIOWritable(false);
@@ -114,6 +114,11 @@ RimEclipseStatisticsCase::RimEclipseStatisticsCase()
CAF_PDM_InitField(&m_useZeroAsInactiveCellValue, "UseZeroAsInactiveCellValue", false, "Use Zero as Inactive Cell Value", "", "", "");
m_populateSelectionAfterLoadingGrid = false;
// These does not work properly for statistics case, so hide for now
flipXAxis.uiCapability()->setUiHidden(true);
flipYAxis.uiCapability()->setUiHidden(true);
activeFormationNames.uiCapability()->setUiHidden(true);
}
//--------------------------------------------------------------------------------------------------
@@ -339,12 +344,16 @@ void RimEclipseStatisticsCase::defineUiOrdering(QString uiConfigName, caf::PdmUi
updatePercentileUiVisibility();
uiOrdering.add(&caseUserDescription);
uiOrdering.add(&caseId);
uiOrdering.add(&m_calculateEditCommand);
uiOrdering.add(&m_selectionSummary);
caf::PdmUiGroup * group = uiOrdering.addNewGroup("Properties to consider");
uiOrdering.add(&m_calculateEditCommand);
caf::PdmUiGroup * group = uiOrdering.addNewGroup("Summary of Calculation Setup");
group->add(&m_useZeroAsInactiveCellValue);
m_useZeroAsInactiveCellValue.uiCapability()->setUiHidden(hasComputedStatistics());
group->add(&m_selectionSummary);
group = uiOrdering.addNewGroup("Properties to consider");
group->setUiHidden(hasComputedStatistics());
group->add(&m_resultType);
group->add(&m_porosityModel);
@@ -357,8 +366,6 @@ void RimEclipseStatisticsCase::defineUiOrdering(QString uiConfigName, caf::PdmUi
group->add(&m_selectedFractureGeneratedProperties);
group->add(&m_selectedFractureInputProperties);
uiOrdering.add(&m_useZeroAsInactiveCellValue);
m_useZeroAsInactiveCellValue.uiCapability()->setUiHidden(hasComputedStatistics());
group = uiOrdering.addNewGroup("Percentile setup");
group->setUiHidden(hasComputedStatistics());
@@ -368,6 +375,11 @@ void RimEclipseStatisticsCase::defineUiOrdering(QString uiConfigName, caf::PdmUi
group->add(&m_midPercentile);
group->add(&m_highPercentile);
group = uiOrdering.addNewGroup("Case Options");
group->add(&m_wellDataSourceCase);
group->add(&activeFormationNames);
group->add(&flipXAxis);
group->add(&flipYAxis);
}
QList<caf::PdmOptionItemInfo> toOptionList(const QStringList& varList)
@@ -451,6 +463,7 @@ QList<caf::PdmOptionItemInfo> RimEclipseStatisticsCase::calculateValueOptions(co
return toOptionList(sourceCaseNames);
}
if (!options.size()) options = RimEclipseCase::calculateValueOptions(fieldNeedingOptions, useOptionsOnly);
return options;
}
@@ -460,6 +473,8 @@ QList<caf::PdmOptionItemInfo> RimEclipseStatisticsCase::calculateValueOptions(co
//--------------------------------------------------------------------------------------------------
void RimEclipseStatisticsCase::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
RimEclipseCase::fieldChangedByUi(changedField, oldValue, newValue);
if (&m_resultType == changedField || &m_porosityModel == changedField)
{
}
@@ -701,7 +716,7 @@ void RimEclipseStatisticsCase::computeStatisticsAndUpdateViews()
if (reservoirViews.size() == 0)
{
RicNewViewFeature::addReservoirView();
RicNewViewFeature::addReservoirView(this, nullptr);
}
}

26
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@@ -440,14 +440,18 @@ void RimEclipseView::createDisplayModel()
*/
// Well path model
RigMainGrid* mainGrid = this->mainGrid();
m_wellPathPipeVizModel->removeAllParts();
addWellPathsToModel(m_wellPathPipeVizModel.p(),
mainGrid->displayModelOffset(),
mainGrid->characteristicIJCellSize(),
currentActiveCellInfo()->geometryBoundingBox(),
m_reservoirGridPartManager->scaleTransform());
RigMainGrid* mainGrid = this->mainGrid();
if (mainGrid)
{
addWellPathsToModel(m_wellPathPipeVizModel.p(),
mainGrid->displayModelOffset(),
mainGrid->characteristicIJCellSize(),
currentActiveCellInfo()->geometryBoundingBox(),
m_reservoirGridPartManager->scaleTransform());
}
m_viewer->addStaticModelOnce(m_wellPathPipeVizModel.p());
@@ -1337,15 +1341,7 @@ const std::vector<RivCellSetEnum>& RimEclipseView::visibleGridParts() const
//--------------------------------------------------------------------------------------------------
void RimEclipseView::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup* viewGroup = uiOrdering.addNewGroup("Viewer");
viewGroup->add(&name);
viewGroup->add(&backgroundColor);
viewGroup->add(&showGridBox);
caf::PdmUiGroup* gridGroup = uiOrdering.addNewGroup("Grid Appearance");
gridGroup->add(&scaleZ);
gridGroup->add(&meshMode);
gridGroup->add(&surfaceMode);
RimView::defineUiOrdering(uiConfigName, uiOrdering);
caf::PdmUiGroup* cellGroup = uiOrdering.addNewGroup("Cell Visibility");
cellGroup->add(&showMainGrid);

21
ApplicationCode/ProjectDataModel/RimEclipseWell.cpp
View File

@@ -61,8 +61,8 @@ RimEclipseWell::RimEclipseWell()
CAF_PDM_InitField(&showWellPipe, "ShowWellPipe", true, "Pipe", "", "", "");
CAF_PDM_InitField(&showWellSpheres, "ShowWellSpheres", false, "Spheres", "", "", "");
CAF_PDM_InitField(&wellHeadScaleFactor, "WellHeadScaleFactor", 1.0, "Well Head Scale Factor", "", "", "");
CAF_PDM_InitField(&pipeScaleFactor, "WellPipeRadiusScale", 1.0, "Pipe Scale Factor", "", "", "");
CAF_PDM_InitField(&wellHeadScaleFactor, "WellHeadScaleFactor", 1.0, "Well Head Scale", "", "", "");
CAF_PDM_InitField(&pipeScaleFactor, "WellPipeRadiusScale", 1.0, "Pipe Radius Scale", "", "", "");
CAF_PDM_InitField(&wellPipeColor, "WellPipeColor", cvf::Color3f(0.588f, 0.588f, 0.804f), "Pipe Color", "", "", "");
CAF_PDM_InitField(&showWellCells, "ShowWellCells", false, "Well Cells", "", "", "");
@@ -353,16 +353,17 @@ void RimEclipseWell::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering&
appearanceGroup->add(&showWellPipe);
appearanceGroup->add(&showWellSpheres);
caf::PdmUiGroup* sizeScalingGroup = uiOrdering.addNewGroup("Size Scaling");
sizeScalingGroup->add(&pipeScaleFactor);
sizeScalingGroup->add(&wellHeadScaleFactor);
uiOrdering.add(&wellPipeColor);
uiOrdering.add(&showWellCells);
uiOrdering.add(&showWellCellFence);
caf::PdmUiGroup* filterGroup = uiOrdering.addNewGroup("Well Cells and Fence");
filterGroup->add(&showWellCells);
filterGroup->add(&showWellCellFence);
showWellCellFence.uiCapability()->setUiReadOnly(!showWellCells());
caf::PdmUiGroup* sizeScalingGroup = uiOrdering.addNewGroup("Size Scaling");
sizeScalingGroup->add(&wellHeadScaleFactor);
sizeScalingGroup->add(&pipeScaleFactor);
caf::PdmUiGroup* colorGroup = uiOrdering.addNewGroup("Colors");
colorGroup->add(&wellPipeColor);
uiOrdering.skipRemainingFields(true);
}

87
ApplicationCode/ProjectDataModel/RimEclipseWellCollection.cpp
View File

@@ -87,8 +87,8 @@ namespace caf
template<>
void RimEclipseWellCollection::WellHeadPositionEnum::setUp()
{
addItem(RimEclipseWellCollection::WELLHEAD_POS_ACTIVE_CELLS_BB, "WELLHEAD_POS_ACTIVE_CELLS_BB", "All Active Cells");
addItem(RimEclipseWellCollection::WELLHEAD_POS_TOP_COLUMN, "WELLHEAD_POS_TOP_COLUMN", "Active Cell Column");
addItem(RimEclipseWellCollection::WELLHEAD_POS_ACTIVE_CELLS_BB, "WELLHEAD_POS_ACTIVE_CELLS_BB", "Top of Active Cells");
addItem(RimEclipseWellCollection::WELLHEAD_POS_TOP_COLUMN, "WELLHEAD_POS_TOP_COLUMN", "Top of Active Cell Column");
setDefault(RimEclipseWellCollection::WELLHEAD_POS_TOP_COLUMN);
}
}
@@ -116,7 +116,9 @@ RimEclipseWellCollection::RimEclipseWellCollection()
CAF_PDM_InitField(&isActive, "Active", true, "Active", "", "", "");
isActive.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&showWellsIntersectingVisibleCells, "ShowWellsIntersectingVisibleCells", false, "Hide Wells Not Intersecting Filtered Cells", "", "", "");
//CAF_PDM_InitField(&showWellsIntersectingVisibleCells, "ShowWellsIntersectingVisibleCells", false, "Hide Wells Not Intersecting Filtered Cells", "", "", "");
CAF_PDM_InitField(&showWellsIntersectingVisibleCells, "ShowWellsIntersectingVisibleCells", false, "Wells Through Visible Cells Only", "", "", "");
//CAF_PDM_InitField(&showWellsIntersectingVisibleCells, "ShowWellsIntersectingVisibleCells", false, "Hide Wells Missing Visible Cells", "", "", "");
// Appearance
CAF_PDM_InitFieldNoDefault(&m_showWellHead, "ShowWellHeadTristate", "Well Head", "", "", "");
@@ -141,28 +143,28 @@ RimEclipseWellCollection::RimEclipseWellCollection()
m_showWellSpheres.xmlCapability()->setIOWritable(false);
// Scaling
CAF_PDM_InitField(&wellHeadScaleFactor, "WellHeadScale", 1.0, "Well Head Scale Factor", "", "", "");
CAF_PDM_InitField(&pipeScaleFactor, "WellPipeRadiusScale", 0.1, "Well Pipe Scale Factor", "", "", "");
CAF_PDM_InitField(&spheresScaleFactor, "CellCenterSphereScale", 0.2, "Well Sphere Scale Factor", "", "", "");
CAF_PDM_InitField(&wellHeadScaleFactor, "WellHeadScale", 1.0, "Well Head Scale", "", "", "");
CAF_PDM_InitField(&pipeScaleFactor, "WellPipeRadiusScale", 0.1, "Pipe Radius Scale ", "", "", "");
CAF_PDM_InitField(&spheresScaleFactor, "CellCenterSphereScale", 0.2, "Sphere Radius Scale", "", "", "");
// Color
cvf::Color3f defWellLabelColor = RiaApplication::instance()->preferences()->defaultWellLabelColor();
CAF_PDM_InitField(&wellLabelColor, "WellLabelColor", defWellLabelColor, "Well Label Color", "", "", "");
CAF_PDM_InitField(&wellLabelColor, "WellLabelColor", defWellLabelColor, "Label Color", "", "", "");
CAF_PDM_InitField(&showConnectionStatusColors, "ShowConnectionStatusColors", true, "Show Connection Status Colors Along Well", "", "", "");
CAF_PDM_InitField(&showConnectionStatusColors, "ShowConnectionStatusColors", true, "Color Pipe Connections", "", "", "");
cvf::Color3f defaultApplyColor = cvf::Color3f::YELLOW;
CAF_PDM_InitField(&m_wellColorForApply, "WellColorForApply", defaultApplyColor, "Well Color", "", "", "");
CAF_PDM_InitField(&m_wellColorForApply, "WellColorForApply", defaultApplyColor, "", "", "", "");
CAF_PDM_InitField(&m_applySingleColorToWells, "ApplySingleColorToWells", false, "", "", "", "");
CAF_PDM_InitField(&m_applySingleColorToWells, "ApplySingleColorToWells", false, "Uniform Pipe Colors", "", "", "");
m_applySingleColorToWells.uiCapability()->setUiEditorTypeName(caf::PdmUiPushButtonEditor::uiEditorTypeName());
m_applySingleColorToWells.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
m_applySingleColorToWells.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::LEFT);
m_applySingleColorToWells.xmlCapability()->setIOReadable(false);
m_applySingleColorToWells.xmlCapability()->setIOWritable(false);
CAF_PDM_InitField(&m_applyIndividualColorsToWells, "ApplyIndividualColorsToWells", false, "", "", "", "");
CAF_PDM_InitField(&m_applyIndividualColorsToWells, "ApplyIndividualColorsToWells", false, "Unique Pipe Colors", "", "", "");
m_applyIndividualColorsToWells.uiCapability()->setUiEditorTypeName(caf::PdmUiPushButtonEditor::uiEditorTypeName());
m_applyIndividualColorsToWells.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
m_applyIndividualColorsToWells.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::LEFT);
m_applyIndividualColorsToWells.xmlCapability()->setIOReadable(false);
m_applyIndividualColorsToWells.xmlCapability()->setIOWritable(false);
@@ -178,8 +180,8 @@ RimEclipseWellCollection::RimEclipseWellCollection()
CAF_PDM_InitField(&wellCellFenceType, "DefaultWellFenceDirection", WellFenceEnum(K_DIRECTION), "Well Fence Direction", "", "", "");
CAF_PDM_InitField(&wellCellTransparencyLevel, "WellCellTransparency", 0.5, "Well Cell Transparency", "", "", "");
CAF_PDM_InitField(&isAutoDetectingBranches, "IsAutoDetectingBranches", true, "Branch Detection", "", "Toggle wether the well pipe visualization will try to detect when a part of the well \nis really a branch, and thus is starting from wellhead", "");
CAF_PDM_InitField(&wellHeadPosition, "WellHeadPosition", WellHeadPositionEnum(WELLHEAD_POS_TOP_COLUMN), "Well Head Position On Top Of", "", "", "");
CAF_PDM_InitField(&isAutoDetectingBranches, "IsAutoDetectingBranches", true, "Branch Detection", "", "Toggle whether the well pipe visualization will try to detect when a part of the well \nis really a branch, and thus is starting from wellhead", "");
CAF_PDM_InitField(&wellHeadPosition, "WellHeadPosition", WellHeadPositionEnum(WELLHEAD_POS_TOP_COLUMN), "Well Head Position", "", "", "");
CAF_PDM_InitFieldNoDefault(&wells, "Wells", "Wells", "", "", "");
wells.uiCapability()->setUiHidden(true);
@@ -201,7 +203,7 @@ RimEclipseWellCollection::RimEclipseWellCollection()
CAF_PDM_InitField(&obsoleteField_showWellLabel, "ShowWellLabel", true, "Show Well Label", "", "", "");
CAF_PDM_InitField(&obsoleteField_showWellCellFence, "ShowWellFences", false, "Show Well Cell Fence", "", "", "");
CAF_PDM_InitField(&m_showWellCommunicationLines, "ShowWellCommunicationLines", false, "Show Communication Lines", "", "", "");
CAF_PDM_InitField(&m_showWellCommunicationLines, "ShowWellCommunicationLines", false, "Communication Lines", "", "", "");
obsoleteField_showWellHead.uiCapability()->setUiHidden(true);
obsoleteField_showWellLabel.uiCapability()->setUiHidden(true);
@@ -474,23 +476,17 @@ void RimEclipseWellCollection::fieldChangedByUi(const caf::PdmFieldHandle* chang
//--------------------------------------------------------------------------------------------------
void RimEclipseWellCollection::assignDefaultWellColors()
{
const caf::ColorTable& colorTable = RiaColorTables::wellsPaletteColors();
cvf::Color3ubArray wellColors = colorTable.color3ubArray();
cvf::Color3ubArray interpolatedWellColors = wellColors;
if (wells.size() > 1)
{
interpolatedWellColors = caf::ColorTable::interpolateColorArray(wellColors, wells.size());
}
RimEclipseCase* ownerCase;
firstAncestorOrThisOfTypeAsserted(ownerCase);
for (size_t wIdx = 0; wIdx < wells.size(); ++wIdx)
{
RimEclipseWell* well = wells[wIdx];
if (well)
if (well && well->wellResults() )
{
cvf::Color3f col = cvf::Color3f(interpolatedWellColors[wIdx]);
well->wellPipeColor = col;
well->updateConnectedEditors();
well->wellPipeColor = ownerCase->defaultWellColor(well->wellResults()->m_wellName);
}
}
@@ -528,42 +524,41 @@ void RimEclipseWellCollection::defineUiOrdering(QString uiConfigName, caf::PdmUi
{
updateStateForVisibilityCheckboxes();
uiOrdering.add(&showWellsIntersectingVisibleCells);
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Visibility");
appearanceGroup->add(&showWellsIntersectingVisibleCells);
appearanceGroup->add(&m_showWellLabel);
appearanceGroup->add(&m_showWellHead);
appearanceGroup->add(&m_showWellPipe);
appearanceGroup->add(&m_showWellSpheres);
appearanceGroup->add(&m_showWellCommunicationLines);
caf::PdmUiGroup* filterGroup = uiOrdering.addNewGroup("Well Cells and Fence");
filterGroup->add(&m_showWellCells);
filterGroup->add(&m_showWellCellFence);
filterGroup->add(&wellCellFenceType);
caf::PdmUiGroup* sizeScalingGroup = uiOrdering.addNewGroup("Size Scaling");
sizeScalingGroup->add(&wellHeadScaleFactor);
sizeScalingGroup->add(&pipeScaleFactor);
sizeScalingGroup->add(&spheresScaleFactor);
caf::PdmUiGroup* colorGroup = uiOrdering.addNewGroup("Color");
caf::PdmUiGroup* colorGroup = uiOrdering.addNewGroup("Colors");
colorGroup->setCollapsedByDefault(true);
colorGroup->add(&showConnectionStatusColors);
colorGroup->add(&wellLabelColor);
colorGroup->add(&m_applyIndividualColorsToWells);
colorGroup->add(&m_applySingleColorToWells);
colorGroup->add(&m_wellColorForApply);
caf::PdmUiGroup* singleWellColorGroup = colorGroup->addNewGroup("Uniform Well Coloring");
singleWellColorGroup->add(&m_wellColorForApply);
singleWellColorGroup->add(&m_applySingleColorToWells);
caf::PdmUiGroup* wellPipeGroup = uiOrdering.addNewGroup("Well Pipe Geometry");
caf::PdmUiGroup* wellPipeGroup = uiOrdering.addNewGroup("Well Pipe Geometry" );
wellPipeGroup->add(&wellPipeCoordType);
wellPipeGroup->add(&isAutoDetectingBranches);
wellPipeGroup->add(&showConnectionStatusColors);
caf::PdmUiGroup* advancedGroup = uiOrdering.addNewGroup("Advanced");
advancedGroup->setCollapsedByDefault(true);
advancedGroup->add(&wellCellTransparencyLevel);
advancedGroup->add(&wellHeadPosition);
caf::PdmUiGroup* filterGroup = uiOrdering.addNewGroup("Well Cells");
filterGroup->add(&obsoleteField_wellCellsToRangeFilterMode);
filterGroup->add(&m_showWellCells);
filterGroup->add(&m_showWellCellFence);
filterGroup->add(&wellCellFenceType);
RimEclipseResultCase* ownerCase;
firstAncestorOrThisOfTypeAsserted(ownerCase);
m_showWellCommunicationLines.uiCapability()->setUiHidden(!ownerCase->flowDiagSolverInterface());
@@ -712,7 +707,7 @@ void RimEclipseWellCollection::defineEditorAttribute(const caf::PdmFieldHandle*
caf::PdmUiPushButtonEditorAttribute* editorAttr = dynamic_cast<caf::PdmUiPushButtonEditorAttribute*>(attribute);
if (editorAttr)
{
editorAttr->m_buttonText = "Apply Default Well Colors";
editorAttr->m_buttonText = "Apply";
}
}
@@ -724,13 +719,13 @@ void RimEclipseWellCollection::defineEditorAttribute(const caf::PdmFieldHandle*
QColor col;
col.setRgbF(m_wellColorForApply().r(), m_wellColorForApply().g(), m_wellColorForApply().b());
QPixmap pixmap(100, 100);
QPixmap pixmap(20, 20);
pixmap.fill(col);
QIcon colorIcon(pixmap);
editorAttr->m_buttonIcon = colorIcon;
editorAttr->m_buttonText = "Apply Uniform Well Color";
editorAttr->m_buttonText = "Apply";
}
}
}

2
ApplicationCode/ProjectDataModel/RimGeoMechCase.cpp
View File

@@ -50,7 +50,7 @@ RimGeoMechCase::RimGeoMechCase(void)
{
CAF_PDM_InitObject("Geomechanical Case", ":/GeoMechCase48x48.png", "", "");
CAF_PDM_InitField(&m_caseFileName, "CaseFileName", QString(), "Case file name", "", "", "");
CAF_PDM_InitField(&m_caseFileName, "CaseFileName", QString(), "Case File Name", "", "", "");
m_caseFileName.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitFieldNoDefault(&geoMechViews, "GeoMechViews", "", "", "", "");
geoMechViews.uiCapability()->setUiHidden(true);

11
ApplicationCode/ProjectDataModel/RimGeoMechPropertyFilter.cpp
View File

@@ -135,17 +135,18 @@ void RimGeoMechPropertyFilter::defineUiOrdering(QString uiConfigName, caf::PdmUi
caf::PdmUiGroup* group1 = uiOrdering.addNewGroup("Result");
resultDefinition->uiOrdering(uiConfigName, *group1);
uiOrdering.add(&isActive);
uiOrdering.add(&filterMode);
caf::PdmUiGroup& group2 = *(uiOrdering.addNewGroup("Filter Settings"));
group2.add(&filterMode);
if ( resultDefinition->hasCategoryResult() )
{
uiOrdering.add(&m_selectedCategoryValues);
group2.add(&m_selectedCategoryValues);
}
else
{
uiOrdering.add(&lowerBound);
uiOrdering.add(&upperBound);
group2.add(&lowerBound);
group2.add(&upperBound);
}
updateReadOnlyStateOfAllFields();

8
ApplicationCode/ProjectDataModel/RimPickingTopologyItem.cpp → ApplicationCode/ProjectDataModel/RimGeometrySelectionItem.cpp
View File

@@ -16,23 +16,23 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RimPickingTopologyItem.h"
#include "RimGeometrySelectionItem.h"
CAF_PDM_XML_ABSTRACT_SOURCE_INIT(RimPickingTopologyItem, "RimPickingTopologyItem");
CAF_PDM_XML_ABSTRACT_SOURCE_INIT(RimGeometrySelectionItem, "GeometrySelectionItem");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPickingTopologyItem::RimPickingTopologyItem()
RimGeometrySelectionItem::RimGeometrySelectionItem()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPickingTopologyItem::~RimPickingTopologyItem()
RimGeometrySelectionItem::~RimGeometrySelectionItem()
{
}

8
ApplicationCode/ProjectDataModel/RimPickingTopologyItem.h → ApplicationCode/ProjectDataModel/RimGeometrySelectionItem.h
View File

@@ -20,13 +20,13 @@
#include "cafPdmObject.h"
class RimPickingTopologyItem : public caf::PdmObject
class RimGeometrySelectionItem : public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
RimPickingTopologyItem();
virtual ~RimPickingTopologyItem();
RimGeometrySelectionItem();
virtual ~RimGeometrySelectionItem();
virtual QString topologyText() const = 0;
virtual QString geometrySelectionText() const = 0;
};

116
ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.cpp
View File

@@ -28,10 +28,10 @@
#include "RimEclipseCase.h"
#include "RimEclipseCellColors.h"
#include "RimEclipseResultDefinition.h"
#include "RimEclipseTopologyItem.h"
#include "RimEclipseGeometrySelectionItem.h"
#include "RimEclipseView.h"
#include "RimGeoMechCase.h"
#include "RimGeoMechTopologyItem.h"
#include "RimGeoMechGeometrySelectionItem.h"
#include "RimGeoMechResultDefinition.h"
#include "RimGeoMechView.h"
#include "RimProject.h"
@@ -45,7 +45,7 @@
#include "qwt_plot.h"
CAF_PDM_SOURCE_INIT(RimGridTimeHistoryCurve, "TimeHistoryCurve");
CAF_PDM_SOURCE_INIT(RimGridTimeHistoryCurve, "GridTimeHistoryCurve");
//--------------------------------------------------------------------------------------------------
///
@@ -54,9 +54,9 @@ RimGridTimeHistoryCurve::RimGridTimeHistoryCurve()
{
CAF_PDM_InitObject("Grid Time History Curve", ":/SummaryCurve16x16.png", "", "");
CAF_PDM_InitFieldNoDefault(&m_topologyText, "TopologyText", "Topology Reference", "", "", "");
m_topologyText.registerGetMethod(this, &RimGridTimeHistoryCurve::topologyText);
m_topologyText.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitFieldNoDefault(&m_geometrySelectionText, "GeometrySelectionText", "Cell Reference", "", "", "");
m_geometrySelectionText.registerGetMethod(this, &RimGridTimeHistoryCurve::geometrySelectionText);
m_geometrySelectionText.uiCapability()->setUiReadOnly(true);
CAF_PDM_InitFieldNoDefault(&m_eclipseResultDefinition, "EclipseResultDefinition", "Eclipse Result definition", "", "", "");
m_eclipseResultDefinition.uiCapability()->setUiHidden(true);
@@ -66,9 +66,9 @@ RimGridTimeHistoryCurve::RimGridTimeHistoryCurve()
m_geoMechResultDefinition.uiCapability()->setUiHidden(true);
m_geoMechResultDefinition.uiCapability()->setUiTreeChildrenHidden(true);
CAF_PDM_InitFieldNoDefault(&m_pickingTopologyItem, "PickingTopologyItem", "Picking Topology Item", "", "", "");
m_pickingTopologyItem.uiCapability()->setUiTreeHidden(true);
m_pickingTopologyItem.uiCapability()->setUiTreeChildrenHidden(true);
CAF_PDM_InitFieldNoDefault(&m_geometrySelectionItem, "GeometrySelectionItem", "Geometry Selection", "", "", "");
m_geometrySelectionItem.uiCapability()->setUiTreeHidden(true);
m_geometrySelectionItem.uiCapability()->setUiTreeChildrenHidden(true);
CAF_PDM_InitField(&m_plotAxis, "PlotAxis", caf::AppEnum< RimDefines::PlotAxis >(RimDefines::PLOT_AXIS_LEFT), "Axis", "", "", "");
}
@@ -85,9 +85,9 @@ RimGridTimeHistoryCurve::~RimGridTimeHistoryCurve()
//--------------------------------------------------------------------------------------------------
void RimGridTimeHistoryCurve::setFromSelectionItem(const RiuSelectionItem* selectionItem)
{
if (m_pickingTopologyItem())
if (m_geometrySelectionItem())
{
delete m_pickingTopologyItem();
delete m_geometrySelectionItem();
}
if (m_eclipseResultDefinition())
@@ -103,10 +103,10 @@ void RimGridTimeHistoryCurve::setFromSelectionItem(const RiuSelectionItem* selec
const RiuEclipseSelectionItem* eclSelectionItem = dynamic_cast<const RiuEclipseSelectionItem*>(selectionItem);
if (eclSelectionItem)
{
RimEclipseTopologyItem* topologyItem = new RimEclipseTopologyItem;
m_pickingTopologyItem = topologyItem;
RimEclipseGeometrySelectionItem* geomSelectionItem = new RimEclipseGeometrySelectionItem;
m_geometrySelectionItem = geomSelectionItem;
topologyItem->setFromSelectionItem(eclSelectionItem);
geomSelectionItem->setFromSelectionItem(eclSelectionItem);
if (eclSelectionItem->m_view)
{
@@ -118,10 +118,10 @@ void RimGridTimeHistoryCurve::setFromSelectionItem(const RiuSelectionItem* selec
const RiuGeoMechSelectionItem* geoMechSelectionItem = dynamic_cast<const RiuGeoMechSelectionItem*>(selectionItem);
if (geoMechSelectionItem)
{
RimGeoMechTopologyItem* topologyItem = new RimGeoMechTopologyItem;
m_pickingTopologyItem = topologyItem;
RimGeoMechGeometrySelectionItem* geomSelectionItem = new RimGeoMechGeometrySelectionItem;
m_geometrySelectionItem = geomSelectionItem;
topologyItem->setFromSelectionItem(geoMechSelectionItem);
geomSelectionItem->setFromSelectionItem(geoMechSelectionItem);
if (geoMechSelectionItem->m_view)
{
@@ -159,7 +159,7 @@ std::vector<double> RimGridTimeHistoryCurve::yValues() const
{
std::vector<double> values;
RimEclipseTopologyItem* eclTopItem = eclipseTopologyItem();
RimEclipseGeometrySelectionItem* eclTopItem = eclipseGeomSelectionItem();
if (eclTopItem && eclTopItem->eclipseCase())
{
size_t cellIndex = eclTopItem->cellIndex();
@@ -176,7 +176,7 @@ std::vector<double> RimGridTimeHistoryCurve::yValues() const
values = RigTimeHistoryResultAccessor::timeHistoryValues(eclTopItem->eclipseCase()->eclipseCaseData(), m_eclipseResultDefinition(), gridIndex, cellIndex, timeStepDates.size());
}
if (geoMechTopologyItem() && geoMechTopologyItem()->geoMechCase())
if (geoMechGeomSelectionItem() && geoMechGeomSelectionItem()->geoMechCase())
{
std::unique_ptr<RiuFemTimeHistoryResultAccessor> timeHistResultAccessor = femTimeHistoryResultAccessor();
@@ -194,7 +194,7 @@ std::vector<double> RimGridTimeHistoryCurve::yValues() const
//--------------------------------------------------------------------------------------------------
QString RimGridTimeHistoryCurve::quantityName() const
{
RimEclipseTopologyItem* eclTopItem = eclipseTopologyItem();
RimEclipseGeometrySelectionItem* eclTopItem = eclipseGeomSelectionItem();
if (eclTopItem)
{
CVF_ASSERT(m_eclipseResultDefinition());
@@ -202,11 +202,11 @@ QString RimGridTimeHistoryCurve::quantityName() const
return m_eclipseResultDefinition->resultVariableUiName();
}
if (geoMechTopologyItem())
if (geoMechGeomSelectionItem())
{
CVF_ASSERT(m_geoMechResultDefinition());
RimGeoMechTopologyItem* geoMechTopItem = geoMechTopologyItem();
RimGeoMechGeometrySelectionItem* geoMechTopItem = geoMechGeomSelectionItem();
std::unique_ptr<RiuFemTimeHistoryResultAccessor> timeHistResultAccessor = femTimeHistoryResultAccessor();
QString text;
@@ -239,13 +239,13 @@ QString RimGridTimeHistoryCurve::quantityName() const
//--------------------------------------------------------------------------------------------------
QString RimGridTimeHistoryCurve::caseName() const
{
RimEclipseTopologyItem* eclTopItem = eclipseTopologyItem();
RimEclipseGeometrySelectionItem* eclTopItem = eclipseGeomSelectionItem();
if (eclTopItem && eclTopItem->eclipseCase())
{
return eclTopItem->eclipseCase()->caseUserDescription();
}
RimGeoMechTopologyItem* geoMechTopItem = geoMechTopologyItem();
RimGeoMechGeometrySelectionItem* geoMechTopItem = geoMechGeomSelectionItem();
if (geoMechTopItem && geoMechTopItem->geoMechCase())
{
return geoMechTopItem->geoMechCase()->caseUserDescription();
@@ -263,7 +263,7 @@ QString RimGridTimeHistoryCurve::createCurveAutoName()
text += quantityName();
QString topoText = topologyText();
QString topoText = geometrySelectionText();
if (!topoText.isEmpty())
{
@@ -297,13 +297,13 @@ void RimGridTimeHistoryCurve::onLoadDataAndUpdate()
std::vector<time_t> dateTimes;
std::vector<double> values;
RimEclipseTopologyItem* eclTopItem = eclipseTopologyItem();
RimEclipseGeometrySelectionItem* eclTopItem = eclipseGeomSelectionItem();
if (eclTopItem && eclTopItem->eclipseCase())
{
m_eclipseResultDefinition->loadResult();
}
RimGeoMechTopologyItem* geoMechTopItem = geoMechTopologyItem();
RimGeoMechGeometrySelectionItem* geoMechTopItem = geoMechGeomSelectionItem();
if (geoMechTopItem && geoMechTopItem->geoMechCase())
{
m_geoMechResultDefinition->loadResult();
@@ -360,7 +360,7 @@ std::vector<time_t> RimGridTimeHistoryCurve::timeStepValues() const
{
std::vector<time_t> dateTimes;
RimEclipseTopologyItem* eclTopItem = eclipseTopologyItem();
RimEclipseGeometrySelectionItem* eclTopItem = eclipseGeomSelectionItem();
if (eclTopItem && eclTopItem->eclipseCase())
{
RimReservoirCellResultsStorage* cellResStorage = m_eclipseResultDefinition->currentGridCellResults();
@@ -374,7 +374,7 @@ std::vector<time_t> RimGridTimeHistoryCurve::timeStepValues() const
}
}
RimGeoMechTopologyItem* geoMechTopItem = geoMechTopologyItem();
RimGeoMechGeometrySelectionItem* geoMechTopItem = geoMechGeomSelectionItem();
if (geoMechTopItem && geoMechTopItem->geoMechCase())
{
std::unique_ptr<RiuFemTimeHistoryResultAccessor> timeHistResultAccessor = femTimeHistoryResultAccessor();
@@ -411,23 +411,31 @@ void RimGridTimeHistoryCurve::defineUiOrdering(QString uiConfigName, caf::PdmUiO
{
RimPlotCurve::updateOptionSensitivity();
uiOrdering.add(&m_topologyText);
uiOrdering.add(&m_geometrySelectionText);
// Fields declared in RimResultDefinition
caf::PdmUiGroup* group1 = uiOrdering.addNewGroup("Result");
if (eclipseTopologyItem())
if (eclipseGeomSelectionItem())
{
CVF_ASSERT(m_eclipseResultDefinition());
m_eclipseResultDefinition->uiOrdering(uiConfigName, *group1);
}
if (geoMechTopologyItem())
if (geoMechGeomSelectionItem())
{
CVF_ASSERT(m_geoMechResultDefinition());
m_geoMechResultDefinition->uiOrdering(uiConfigName, *group1);
}
uiOrdering.add(&m_plotAxis);
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Appearance");
RimPlotCurve::appearanceUiOrdering(*appearanceGroup);
caf::PdmUiGroup* nameGroup = uiOrdering.addNewGroup("Curve Name");
nameGroup->setCollapsedByDefault(true);
RimPlotCurve::curveNameUiOrdering(*nameGroup);
}
//--------------------------------------------------------------------------------------------------
@@ -463,9 +471,9 @@ void RimGridTimeHistoryCurve::fieldChangedByUi(const caf::PdmFieldHandle* change
//--------------------------------------------------------------------------------------------------
RigMainGrid* RimGridTimeHistoryCurve::mainGrid()
{
if (eclipseTopologyItem() && eclipseTopologyItem()->eclipseCase() && eclipseTopologyItem()->eclipseCase()->eclipseCaseData())
if (eclipseGeomSelectionItem() && eclipseGeomSelectionItem()->eclipseCase() && eclipseGeomSelectionItem()->eclipseCase()->eclipseCaseData())
{
return eclipseTopologyItem()->eclipseCase()->eclipseCaseData()->mainGrid();
return eclipseGeomSelectionItem()->eclipseCase()->eclipseCaseData()->mainGrid();
}
return nullptr;
@@ -474,21 +482,21 @@ RigMainGrid* RimGridTimeHistoryCurve::mainGrid()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseTopologyItem* RimGridTimeHistoryCurve::eclipseTopologyItem() const
RimEclipseGeometrySelectionItem* RimGridTimeHistoryCurve::eclipseGeomSelectionItem() const
{
RimPickingTopologyItem* pickItem = m_pickingTopologyItem();
RimGeometrySelectionItem* pickItem = m_geometrySelectionItem();
return dynamic_cast<RimEclipseTopologyItem*>(pickItem);
return dynamic_cast<RimEclipseGeometrySelectionItem*>(pickItem);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGeoMechTopologyItem* RimGridTimeHistoryCurve::geoMechTopologyItem() const
RimGeoMechGeometrySelectionItem* RimGridTimeHistoryCurve::geoMechGeomSelectionItem() const
{
RimPickingTopologyItem* pickItem = m_pickingTopologyItem();
RimGeometrySelectionItem* pickItem = m_geometrySelectionItem();
return dynamic_cast<RimGeoMechTopologyItem*>(pickItem);
return dynamic_cast<RimGeoMechGeometrySelectionItem*>(pickItem);
}
//--------------------------------------------------------------------------------------------------
@@ -496,43 +504,43 @@ RimGeoMechTopologyItem* RimGridTimeHistoryCurve::geoMechTopologyItem() const
//--------------------------------------------------------------------------------------------------
void RimGridTimeHistoryCurve::updateResultDefinitionFromCase()
{
if (eclipseTopologyItem())
if (eclipseGeomSelectionItem())
{
CVF_ASSERT(m_eclipseResultDefinition());
m_eclipseResultDefinition->setEclipseCase(eclipseTopologyItem()->eclipseCase());
m_eclipseResultDefinition->setEclipseCase(eclipseGeomSelectionItem()->eclipseCase());
}
if (geoMechTopologyItem())
if (geoMechGeomSelectionItem())
{
CVF_ASSERT(m_geoMechResultDefinition());
m_geoMechResultDefinition->setGeoMechCase(geoMechTopologyItem()->geoMechCase());
m_geoMechResultDefinition->setGeoMechCase(geoMechGeomSelectionItem()->geoMechCase());
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimGridTimeHistoryCurve::topologyText() const
QString RimGridTimeHistoryCurve::geometrySelectionText() const
{
QString text;
if (eclipseTopologyItem() && m_pickingTopologyItem())
if (eclipseGeomSelectionItem() && m_geometrySelectionItem())
{
text = m_pickingTopologyItem->topologyText();
text = m_geometrySelectionItem->geometrySelectionText();
}
else if (geoMechTopologyItem())
else if (geoMechGeomSelectionItem())
{
std::unique_ptr<RiuFemTimeHistoryResultAccessor> timeHistResultAccessor = femTimeHistoryResultAccessor();
if (timeHistResultAccessor)
{
text = timeHistResultAccessor->topologyText();
text = timeHistResultAccessor->geometrySelectionText();
}
}
else
{
text = "No topology";
text = "No Geometry";
}
return text;
@@ -563,11 +571,11 @@ std::unique_ptr<RiuFemTimeHistoryResultAccessor> RimGridTimeHistoryCurve::femTim
{
std::unique_ptr<RiuFemTimeHistoryResultAccessor> timeHistResultAccessor;
if ( geoMechTopologyItem()
&& geoMechTopologyItem()->geoMechCase()
&& geoMechTopologyItem()->geoMechCase()->geoMechData())
if ( geoMechGeomSelectionItem()
&& geoMechGeomSelectionItem()->geoMechCase()
&& geoMechGeomSelectionItem()->geoMechCase()->geoMechData())
{
RimGeoMechTopologyItem* geoMechTopItem = geoMechTopologyItem();
RimGeoMechGeometrySelectionItem* geoMechTopItem = geoMechGeomSelectionItem();
if (geoMechTopItem->m_hasIntersectionTriangle)
{
std::array<cvf::Vec3f, 3> intersectionTriangle;

16
ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.h
View File

@@ -30,10 +30,10 @@
class RigMainGrid;
class RimEclipseCase;
class RimEclipseResultDefinition;
class RimEclipseTopologyItem;
class RimEclipseGeometrySelectionItem;
class RimGeoMechResultDefinition;
class RimGeoMechTopologyItem;
class RimPickingTopologyItem;
class RimGeoMechGeometrySelectionItem;
class RimGeometrySelectionItem;
class RiuFemTimeHistoryResultAccessor;
class RiuSelectionItem;
@@ -72,21 +72,21 @@ protected:
private:
RigMainGrid* mainGrid();
RimEclipseTopologyItem* eclipseTopologyItem() const;
RimGeoMechTopologyItem* geoMechTopologyItem() const;
RimEclipseGeometrySelectionItem* eclipseGeomSelectionItem() const;
RimGeoMechGeometrySelectionItem* geoMechGeomSelectionItem() const;
void updateResultDefinitionFromCase();
QString topologyText() const;
QString geometrySelectionText() const;
void updateQwtPlotAxis();
std::unique_ptr<RiuFemTimeHistoryResultAccessor> femTimeHistoryResultAccessor() const;
private:
caf::PdmProxyValueField<QString> m_topologyText;
caf::PdmProxyValueField<QString> m_geometrySelectionText;
caf::PdmChildField<RimEclipseResultDefinition*> m_eclipseResultDefinition;
caf::PdmChildField<RimGeoMechResultDefinition*> m_geoMechResultDefinition;
caf::PdmChildField<RimPickingTopologyItem*> m_pickingTopologyItem;
caf::PdmChildField<RimGeometrySelectionItem*> m_geometrySelectionItem;
caf::PdmField< caf::AppEnum< RimDefines::PlotAxis > > m_plotAxis;
};

1
ApplicationCode/ProjectDataModel/RimIdenticalGridCaseGroup.cpp
View File

@@ -387,6 +387,7 @@ RimEclipseStatisticsCase* RimIdenticalGridCaseGroup::createAndAppendStatisticsCa
newStatisticsCase->populateResultSelectionAfterLoadingGrid();
newStatisticsCase->openEclipseGridFile();
newStatisticsCase->eclipseCaseData()->computeActiveCellBoundingBoxes();
return newStatisticsCase;
}

28
ApplicationCode/ProjectDataModel/RimPlotCurve.cpp
View File

@@ -79,14 +79,14 @@ RimPlotCurve::RimPlotCurve()
CAF_PDM_InitField(&m_curveColor, "Color", cvf::Color3f(cvf::Color3::BLACK), "Color", "", "", "");
CAF_PDM_InitField(&m_curveThickness, "Thickness", 1, "Thickness", "", "", "");
CAF_PDM_InitField(&m_curveThickness, "Thickness", 1, "Line Thickness", "", "", "");
m_curveThickness.uiCapability()->setUiEditorTypeName(caf::PdmUiComboBoxEditor::uiEditorTypeName());
caf::AppEnum< RimPlotCurve::LineStyleEnum > lineStyle = STYLE_SOLID;
CAF_PDM_InitField(&m_lineStyle, "LineStyle", lineStyle, "Line style", "", "", "");
CAF_PDM_InitField(&m_lineStyle, "LineStyle", lineStyle, "Line Style", "", "", "");
caf::AppEnum< RimPlotCurve::PointSymbolEnum > pointSymbol = SYMBOL_NONE;
CAF_PDM_InitField(&m_pointSymbol, "PointSymbol", pointSymbol, "Point style", "", "", "");
CAF_PDM_InitField(&m_pointSymbol, "PointSymbol", pointSymbol, "Symbol", "", "", "");
CAF_PDM_InitField(&m_symbolSkipPixelDistance, "SymbolSkipPxDist", 0.0f, "Symbol Skip Distance", "", "Minimum pixel distance between symbols", "");
@@ -265,6 +265,28 @@ void RimPlotCurve::updateOptionSensitivity()
m_curveName.uiCapability()->setUiReadOnly(m_isUsingAutoName);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPlotCurve::appearanceUiOrdering(caf::PdmUiOrdering& uiOrdering)
{
uiOrdering.add(&m_curveColor);
uiOrdering.add(&m_pointSymbol);
uiOrdering.add(&m_symbolSkipPixelDistance);
uiOrdering.add(&m_curveThickness);
uiOrdering.add(&m_lineStyle);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPlotCurve::curveNameUiOrdering(caf::PdmUiOrdering& uiOrdering)
{
uiOrdering.add(&m_isUsingAutoName);
uiOrdering.add(&m_curveName);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/ProjectDataModel/RimPlotCurve.h
View File

@@ -97,6 +97,8 @@ protected:
virtual caf::PdmFieldHandle* objectToggleField();
virtual caf::PdmFieldHandle* userDescriptionField();
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly);
void appearanceUiOrdering(caf::PdmUiOrdering& uiOrdering);
void curveNameUiOrdering(caf::PdmUiOrdering& uiOrdering);
protected:
QPointer<QwtPlot> m_parentQwtPlot;

20
ApplicationCode/ProjectDataModel/RimView.cpp
View File

@@ -260,6 +260,26 @@ void RimView::deleteViewWidget()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimView::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup* viewGroup = uiOrdering.addNewGroup("Viewer");
viewGroup->add(&name);
viewGroup->add(&backgroundColor);
viewGroup->add(&showGridBox);
viewGroup->add(&isPerspectiveView);
viewGroup->add(&m_disableLighting);
caf::PdmUiGroup* gridGroup = uiOrdering.addNewGroup("Grid Appearance");
gridGroup->add(&scaleZ);
gridGroup->add(&meshMode);
gridGroup->add(&surfaceMode);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/ProjectDataModel/RimView.h
View File

@@ -216,6 +216,7 @@ protected:
// Overridden PDM methods:
virtual void setupBeforeSave();
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue);
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
virtual QWidget* createViewWidget(QWidget* mainWindowParent) override;

19
ApplicationCode/ProjectDataModel/RimViewLinker.cpp
View File

@@ -138,26 +138,27 @@ void RimViewLinker::updateCellResult()
if (viewLink->managedView())
{
RimView* rimView = viewLink->managedView();
RimEclipseView* eclipeView = dynamic_cast<RimEclipseView*>(rimView);
if (eclipeView)
RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>(rimView);
if (eclipseView)
{
if (viewLink->isResultColorControlled())
{
eclipeView->cellResult()->simpleCopy(eclipseCellResultDefinition);
eclipseView->cellResult()->simpleCopy(eclipseCellResultDefinition);
eclipseView->cellResult()->loadResult();
if (viewLink->isLegendDefinitionsControlled())
{
eclipeView->cellResult()->legendConfig()->setUiValuesFromLegendConfig(masterEclipseView->cellResult()->legendConfig());
eclipeView->cellResult()->legendConfig()->updateLegend();
eclipseView->cellResult()->legendConfig()->setUiValuesFromLegendConfig(masterEclipseView->cellResult()->legendConfig());
eclipseView->cellResult()->legendConfig()->updateLegend();
eclipeView->cellResult()->ternaryLegendConfig()->setUiValuesFromLegendConfig(masterEclipseView->cellResult()->ternaryLegendConfig());
eclipeView->cellResult()->ternaryLegendConfig()->updateLegend();
eclipseView->cellResult()->ternaryLegendConfig()->setUiValuesFromLegendConfig(masterEclipseView->cellResult()->ternaryLegendConfig());
eclipseView->cellResult()->ternaryLegendConfig()->updateLegend();
}
eclipeView->scheduleCreateDisplayModelAndRedraw();
eclipseView->scheduleCreateDisplayModelAndRedraw();
}
eclipeView->cellResult()->updateIconState();
eclipseView->cellResult()->updateIconState();
}
}
}

32
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@@ -385,9 +385,7 @@ void RimWellLogExtractionCurve::defineUiOrdering(QString uiConfigName, caf::PdmU
if (eclipseCase)
{
curveDataGroup->add(&(m_eclipseResultDefinition->m_resultTypeUiField));
curveDataGroup->add(&(m_eclipseResultDefinition->m_porosityModelUiField));
curveDataGroup->add(&(m_eclipseResultDefinition->m_resultVariableUiField));
m_eclipseResultDefinition->uiOrdering(uiConfigName, *curveDataGroup);
if (m_eclipseResultDefinition->hasDynamicResult())
{
@@ -396,27 +394,25 @@ void RimWellLogExtractionCurve::defineUiOrdering(QString uiConfigName, caf::PdmU
}
else if (geomCase)
{
curveDataGroup->add(&(m_geomResultDefinition->m_resultPositionTypeUiField));
curveDataGroup->add(&(m_geomResultDefinition->m_resultVariableUiField));
m_geomResultDefinition->uiOrdering(uiConfigName, *curveDataGroup);
curveDataGroup->add(&m_timeStep);
}
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Appearance");
appearanceGroup->add(&m_curveColor);
appearanceGroup->add(&m_curveThickness);
appearanceGroup->add(&m_pointSymbol);
appearanceGroup->add(&m_symbolSkipPixelDistance);
appearanceGroup->add(&m_lineStyle);
appearanceGroup->add(&m_curveName);
appearanceGroup->add(&m_isUsingAutoName);
RimPlotCurve::appearanceUiOrdering(*appearanceGroup);
caf::PdmUiGroup* nameGroup = uiOrdering.addNewGroup("Curve Name");
nameGroup->setCollapsedByDefault(true);
RimPlotCurve::curveNameUiOrdering(*nameGroup);
if (m_isUsingAutoName)
{
appearanceGroup->add(&m_addWellNameToCurveName);
appearanceGroup->add(&m_addCaseNameToCurveName);
appearanceGroup->add(&m_addPropertyToCurveName);
appearanceGroup->add(&m_addDateToCurveName);
appearanceGroup->add(&m_addTimestepToCurveName);
nameGroup->add(&m_addWellNameToCurveName);
nameGroup->add(&m_addCaseNameToCurveName);
nameGroup->add(&m_addPropertyToCurveName);
nameGroup->add(&m_addDateToCurveName);
nameGroup->add(&m_addTimestepToCurveName);
}

12
ApplicationCode/ProjectDataModel/RimWellLogFileCurve.cpp
View File

@@ -176,13 +176,11 @@ void RimWellLogFileCurve::defineUiOrdering(QString uiConfigName, caf::PdmUiOrder
curveDataGroup->add(&m_wellLogChannnelName);
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Appearance");
appearanceGroup->add(&m_curveColor);
appearanceGroup->add(&m_curveThickness);
appearanceGroup->add(&m_pointSymbol);
appearanceGroup->add(&m_symbolSkipPixelDistance);
appearanceGroup->add(&m_lineStyle);
appearanceGroup->add(&m_curveName);
appearanceGroup->add(&m_isUsingAutoName);
RimPlotCurve::appearanceUiOrdering(*appearanceGroup);
caf::PdmUiGroup* nameGroup = uiOrdering.addNewGroup("Curve Name");
RimPlotCurve::curveNameUiOrdering(*nameGroup);
}
//--------------------------------------------------------------------------------------------------

22
ApplicationCode/ProjectDataModel/RimWellLogPlot.cpp
View File

@@ -21,6 +21,10 @@
#include "RiaApplication.h"
#include "RigWellLogCurveData.h"
#include "RimWellAllocationPlot.h"
#include "RimWellLogCurve.h"
#include "RimWellLogTrack.h"
#include "RiuMainPlotWindow.h"
@@ -30,9 +34,6 @@
#include "cvfAssert.h"
#include <math.h>
#include "RimWellAllocationPlot.h"
#include "RimWellLogCurve.h"
#include "RigWellLogCurveData.h"
#define RI_LOGPLOT_MINDEPTH_DEFAULT 0.0
#define RI_LOGPLOT_MAXDEPTH_DEFAULT 1000.0
@@ -392,6 +393,18 @@ QString RimWellLogPlot::asciiDataForPlotExport() const
{
QString out;
RimWellAllocationPlot* wellAllocPlot = nullptr;
this->firstAncestorOrThisOfType(wellAllocPlot);
if (wellAllocPlot)
{
out += wellAllocPlot->description();
}
else
{
out += description();
}
out += "\n";
for (RimWellLogTrack* track : m_tracks)
{
if (!track->isVisible()) continue;
@@ -476,12 +489,13 @@ void RimWellLogPlot::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering&
uiOrdering.add(&m_depthUnit);
}
uiOrdering.add(&m_showTrackLegends);
caf::PdmUiGroup* gridGroup = uiOrdering.addNewGroup("Visible Depth Range");
gridGroup->add(&m_isAutoScaleDepthEnabled);
gridGroup->add(&m_minVisibleDepth);
gridGroup->add(&m_maxVisibleDepth);
uiOrdering.add(&m_showTrackLegends);
uiOrdering.skipRemainingFields(true);
}

2
ApplicationCode/ProjectDataModel/RimWellLogTrack.cpp
View File

@@ -395,9 +395,9 @@ void RimWellLogTrack::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering&
caf::PdmUiGroup* gridGroup = uiOrdering.addNewGroup("Visible X Axis Range");
gridGroup->add(&m_isAutoScaleXEnabled);
gridGroup->add(&m_isLogarithmicScaleEnabled);
gridGroup->add(&m_visibleXRangeMin);
gridGroup->add(&m_visibleXRangeMax);
gridGroup->add(&m_isLogarithmicScaleEnabled);
}
//--------------------------------------------------------------------------------------------------

5
ApplicationCode/ProjectDataModel/Summary/RimFileSummaryCase.cpp
View File

@@ -32,8 +32,7 @@ CAF_PDM_SOURCE_INIT(RimFileSummaryCase,"FileSummaryCase");
//--------------------------------------------------------------------------------------------------
RimFileSummaryCase::RimFileSummaryCase()
{
CAF_PDM_InitFieldNoDefault(&m_summaryHeaderFilename, "SummaryHeaderFilename", "Summary Header File", "", "", "");
m_summaryHeaderFilename.uiCapability()->setUiReadOnly(true);
}
//--------------------------------------------------------------------------------------------------
@@ -66,7 +65,7 @@ QString RimFileSummaryCase::summaryHeaderFilename() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimFileSummaryCase::caseName() const
QString RimFileSummaryCase::caseName()
{
QFileInfo caseFileName(this->summaryHeaderFilename());

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

@@ -34,10 +34,9 @@ public:
void setSummaryHeaderFilename(const QString& fileName);
virtual QString summaryHeaderFilename() const override;
virtual QString caseName() const override;
virtual QString caseName() override;
private:
caf::PdmField<QString> m_summaryHeaderFilename;
};

70
ApplicationCode/ProjectDataModel/Summary/RimGridSummaryCase.cpp
View File

@@ -20,6 +20,7 @@
#include "RigSummaryCaseData.h"
#include "RimEclipseCase.h"
#include "RimProject.h"
#include <QFileInfo>
@@ -40,13 +41,14 @@ RimGridSummaryCase::RimGridSummaryCase()
CAF_PDM_InitFieldNoDefault(&m_eclipseCase, "Associated3DCase", "Eclipse Case", "", "", "");
m_eclipseCase.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_cachedCaseName, "CachedCasename", "Case Name", "", "", "");
m_cachedCaseName.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_eclipseGridFileName, "Associated3DCaseGridFileName", "Grid File Name", "", "", "");
m_eclipseGridFileName.registerGetMethod(this, &RimGridSummaryCase::eclipseGridFileName);
m_eclipseGridFileName.uiCapability()->setUiReadOnly(true);
m_eclipseGridFileName.xmlCapability()->setIOWritable(false);
CAF_PDM_InitFieldNoDefault(&m_eclipseSummaryFileName, "SummaryFileName", "Summary File Name", "", "", "");
m_eclipseSummaryFileName.registerGetMethod(this, &RimGridSummaryCase::summaryHeaderFilename);
m_eclipseSummaryFileName.uiCapability()->setUiReadOnly(true);
}
//--------------------------------------------------------------------------------------------------
@@ -57,12 +59,33 @@ RimGridSummaryCase::~RimGridSummaryCase()
}
QString summaryHeaderFilenameFromEclipseCase(RimEclipseCase* eclCase)
{
if (!eclCase) return QString();
QFileInfo gridFileInfo(eclCase->gridFileName());
QString possibleSumHeaderFileName = gridFileInfo.path() +"/"+ gridFileInfo.completeBaseName() + ".SMSPEC";
return possibleSumHeaderFileName;
}
QString caseNameFromEclipseCase(RimEclipseCase* eclCase)
{
if (!eclCase) return QString();
return eclCase->caseUserDescription();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridSummaryCase::setAssociatedEclipseCase(RimEclipseCase* eclipseCase)
{
m_eclipseCase = eclipseCase;
m_summaryHeaderFilename = summaryHeaderFilenameFromEclipseCase(eclipseCase);
m_cachedCaseName = caseNameFromEclipseCase(eclipseCase);
this->updateAutoShortName();
this->updateTreeItemName();
}
@@ -72,6 +95,32 @@ void RimGridSummaryCase::setAssociatedEclipseCase(RimEclipseCase* eclipseCase)
//--------------------------------------------------------------------------------------------------
RimEclipseCase* RimGridSummaryCase::associatedEclipseCase()
{
if (!m_eclipseCase())
{
// Find a possible associated eclipse case
RimProject* project;
firstAncestorOrThisOfTypeAsserted(project);
std::vector<RimCase*> allCases;
project->allCases(allCases);
for ( RimCase* someCase: allCases )
{
auto eclCase = dynamic_cast<RimEclipseCase*>(someCase);
if ( eclCase )
{
QString sumHeaderFileName = summaryHeaderFilenameFromEclipseCase(eclCase);
if ( sumHeaderFileName == m_summaryHeaderFilename )
{
m_eclipseCase = eclCase;
this->updateAutoShortName();
this->updateTreeItemName();
break;
}
}
}
}
return m_eclipseCase();
}
@@ -80,24 +129,19 @@ RimEclipseCase* RimGridSummaryCase::associatedEclipseCase()
//--------------------------------------------------------------------------------------------------
QString RimGridSummaryCase::summaryHeaderFilename() const
{
if (!m_eclipseCase()) return QString();
if (!m_eclipseCase()) return m_summaryHeaderFilename();
QFileInfo gridFileInfo(m_eclipseCase()->gridFileName());
QString possibleSumHeaderFileName = gridFileInfo.path() +"/"+ gridFileInfo.completeBaseName() + ".SMSPEC";
return possibleSumHeaderFileName;
return summaryHeaderFilenameFromEclipseCase(m_eclipseCase());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimGridSummaryCase::caseName() const
QString RimGridSummaryCase::caseName()
{
if (!m_eclipseCase()) return QString();
if (m_eclipseCase()) m_cachedCaseName = caseNameFromEclipseCase(m_eclipseCase());
return m_eclipseCase()->caseUserDescription();
return m_cachedCaseName;
}
//--------------------------------------------------------------------------------------------------

5
ApplicationCode/ProjectDataModel/Summary/RimGridSummaryCase.h
View File

@@ -40,15 +40,16 @@ public:
RimEclipseCase* associatedEclipseCase();
virtual QString summaryHeaderFilename() const override;
virtual QString caseName() const override;
virtual QString caseName() override;
private:
QString eclipseGridFileName() const;
private:
caf::PdmPtrField<RimEclipseCase*> m_eclipseCase;
mutable caf::PdmField<QString> m_cachedCaseName;
caf::PdmProxyValueField<QString> m_eclipseGridFileName;
caf::PdmProxyValueField<QString> m_eclipseSummaryFileName;
//caf::PdmProxyValueField<QString> m_eclipseSummaryFileName;
};

3
ApplicationCode/ProjectDataModel/Summary/RimSummaryCase.cpp
View File

@@ -38,6 +38,9 @@ RimSummaryCase::RimSummaryCase()
CAF_PDM_InitField(&m_shortName, "ShortName", QString("Display Name"), "Display Name", "", "", "");
CAF_PDM_InitField(&m_useAutoShortName, "AutoShortyName", false, "Use Auto Display Name", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_summaryHeaderFilename, "SummaryHeaderFilename", "Summary Header File", "", "", "");
m_summaryHeaderFilename.uiCapability()->setUiReadOnly(true);
}
//--------------------------------------------------------------------------------------------------

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

@@ -39,7 +39,7 @@ public:
virtual ~RimSummaryCase();
virtual QString summaryHeaderFilename() const = 0;
virtual QString caseName() const = 0;
virtual QString caseName() = 0;
QString shortName() const;
void updateAutoShortName();
@@ -53,6 +53,7 @@ protected:
caf::PdmField<QString> m_shortName;
caf::PdmField<bool> m_useAutoShortName;
caf::PdmField<QString> m_summaryHeaderFilename;
cvf::ref<RigSummaryCaseData> m_summaryCaseData;

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

@@ -441,27 +441,24 @@ void RimSummaryCurve::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering&
curveDataGroup->add(&m_selectedVariableDisplayField);
caf::PdmUiGroup* curveVarSelectionGroup = curveDataGroup->addNewGroup("Vector Selection");
curveVarSelectionGroup->setCollapsedByDefault(true);
m_summaryFilter->uiOrdering(uiConfigName, *curveVarSelectionGroup);
curveVarSelectionGroup->add(&m_uiFilterResultSelection);
uiOrdering.add(&m_plotAxis);
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Appearance");
appearanceGroup->add(&m_curveColor);
appearanceGroup->add(&m_curveThickness);
appearanceGroup->add(&m_pointSymbol);
appearanceGroup->add(&m_symbolSkipPixelDistance);
appearanceGroup->add(&m_lineStyle);
appearanceGroup->add(&m_curveName);
appearanceGroup->add(&m_isUsingAutoName);
RimPlotCurve::appearanceUiOrdering(*appearanceGroup);
caf::PdmUiGroup* nameGroup = uiOrdering.addNewGroup("Curve Name");
nameGroup->setCollapsedByDefault(true);
RimPlotCurve::curveNameUiOrdering(*nameGroup);
if (m_isUsingAutoName)
{
caf::PdmUiGroup* autoNameGroup = appearanceGroup->addNewGroup("Auto Name Config");
m_curveNameConfig->uiOrdering(uiConfigName, *autoNameGroup);
m_curveNameConfig->uiOrdering(uiConfigName, *nameGroup);
}
uiOrdering.add(&m_plotAxis);
uiOrdering.skipRemainingFields(); // For now.
}

138
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveAppearanceCalculator.cpp
View File

@@ -21,6 +21,7 @@
#include "RiaColorTables.h"
#include "RimSummaryCurve.h"
#include "RimSummaryCase.h"
#include "cvfVector3.h"
@@ -44,11 +45,14 @@ void caf::AppEnum< RimSummaryCurveAppearanceCalculator::CurveAppearanceType >::s
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSummaryCurveAppearanceCalculator::RimSummaryCurveAppearanceCalculator(const std::set<std::pair<RimSummaryCase*, RifEclipseSummaryAddress> >& curveDefinitions)
RimSummaryCurveAppearanceCalculator::RimSummaryCurveAppearanceCalculator(const std::set<std::pair<RimSummaryCase*, RifEclipseSummaryAddress> >& curveDefinitions, const std::set<std::string> allSummaryCaseNames, const std::set<std::string> allSummaryWellNames)
{
m_allSummaryCaseNames = allSummaryCaseNames;
m_allSummaryWellNames = allSummaryWellNames;
for(const std::pair<RimSummaryCase*, RifEclipseSummaryAddress>& curveDef : curveDefinitions)
{
if(curveDef.first) m_caseToAppearanceIdxMap[curveDef.first] = -1;
if(curveDef.first) m_caseToAppearanceIdxMap[curveDef.first] = -1;
if(!curveDef.second.wellName().empty()) m_welToAppearanceIdxMap[curveDef.second.wellName()] = -1;
if(!curveDef.second.wellGroupName().empty()) m_grpToAppearanceIdxMap[curveDef.second.wellGroupName()] = -1;
if(!(curveDef.second.regionNumber() == -1)) m_regToAppearanceIdxMap[curveDef.second.regionNumber()] = -1;
@@ -106,16 +110,8 @@ RimSummaryCurveAppearanceCalculator::RimSummaryCurveAppearanceCalculator(const s
if (m_dimensionCount == 0) m_varAppearanceType = COLOR; // basically one curve
// Assign increasing indexes
{ int idx = 0; for(auto& pair : m_caseToAppearanceIdxMap) pair.second = idx++; }
{ int idx = 0; for(auto& pair : m_varToAppearanceIdxMap) pair.second = idx++; }
{ int idx = 0; for(auto& pair : m_welToAppearanceIdxMap) pair.second = idx++; }
{ int idx = 0; for(auto& pair : m_grpToAppearanceIdxMap) pair.second = idx++; }
{ int idx = 0; for(auto& pair : m_regToAppearanceIdxMap) pair.second = idx++; }
for (auto& charMapPair : m_secondCharToVarToAppearanceIdxMap)
{ int idx = 0; for(auto& pair : charMapPair.second) pair.second = idx++; }
updateApperanceIndices();
}
//--------------------------------------------------------------------------------------------------
@@ -140,6 +136,126 @@ void RimSummaryCurveAppearanceCalculator::assignDimensions( CurveAppearanceType
if(m_wellAppearanceType != NONE) ++m_dimensionCount;
if(m_groupAppearanceType != NONE) ++m_dimensionCount;
if(m_regionAppearanceType != NONE) ++m_dimensionCount;
updateApperanceIndices();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveAppearanceCalculator::updateApperanceIndices()
{
{
std::map<std::string, size_t> caseAppearanceIndices = mapNameToAppearanceIndex(m_caseAppearanceType, m_allSummaryCaseNames);
int idx = 0;
for (auto& pair : m_caseToAppearanceIdxMap)
{
pair.second = static_cast<int>(caseAppearanceIndices[pair.first->caseName().toUtf8().constData()]);
}
}
{
std::map<std::string, size_t> wellAppearanceIndices = mapNameToAppearanceIndex(m_wellAppearanceType, m_allSummaryWellNames);
int idx = 0;
for (auto& pair : m_welToAppearanceIdxMap)
{
pair.second = static_cast<int>(wellAppearanceIndices[pair.first]);
}
}
// Assign increasing indexes
{ int idx = 0; for(auto& pair : m_varToAppearanceIdxMap) pair.second = idx++; }
{ int idx = 0; for(auto& pair : m_grpToAppearanceIdxMap) pair.second = idx++; }
{ int idx = 0; for(auto& pair : m_regToAppearanceIdxMap) pair.second = idx++; }
for (auto& charMapPair : m_secondCharToVarToAppearanceIdxMap)
{
int idx = 0;
for (auto& pair : charMapPair.second) pair.second = idx++;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::map<std::string, size_t> RimSummaryCurveAppearanceCalculator::mapNameToAppearanceIndex(CurveAppearanceType& appearance, const std::set<std::string>& names)
{
std::map<std::string, size_t> nameToIndex;
size_t numOptions;
if (appearance == CurveAppearanceType::COLOR)
{
numOptions = RiaColorTables::summaryCurveDefaultPaletteColors().size();
}
else if (appearance == CurveAppearanceType::SYMBOL)
{
numOptions = caf::AppEnum<RimPlotCurve::PointSymbolEnum>::size();
}
else if (appearance == CurveAppearanceType::LINE_STYLE)
{
numOptions = caf::AppEnum<RimPlotCurve::LineStyleEnum>::size();
}
else {
// If none of these styles are used, fall back to a simply incrementing index
size_t idx = 0;
for (const std::string& name : names)
{
nameToIndex[name] = idx;
++idx;
}
return nameToIndex;
}
std::hash<std::string> stringHasher;
std::vector< std::set<std::string> > nameIndices;
for (const std::string& name : names)
{
size_t nameHash = stringHasher(name);
nameHash = nameHash % numOptions;
size_t index = nameHash;
while (true)
{
while (nameIndices.size() <= index)
{
// Ensure there exists a set at the insertion index
nameIndices.push_back(std::set<std::string>());
}
std::set<std::string>& matches = nameIndices[index];
if (matches.empty())
{
// If there are no matches here, the summary case has not been added.
matches.insert(name);
break;
}
else if (matches.find(name) != matches.end())
{
// Check to see if the summary case exists at this index.
break;
}
else
{
// Simply increment index to check if the next bucket is available.
index = (index + 1) % numOptions;
if (index == nameHash)
{
// If we've reached `caseHash` again, no other slot was available, so add it here.
matches.insert(name);
break;
}
}
}
}
size_t index = 0;
for (std::set<std::string>& nameIndex : nameIndices)
{
for (const std::string& name : nameIndex)
{
nameToIndex[name] = index;
}
index++;
}
return nameToIndex;
}
//--------------------------------------------------------------------------------------------------

7
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveAppearanceCalculator.h
View File

@@ -31,7 +31,7 @@ class RifEclipseSummaryAddress;
class RimSummaryCurveAppearanceCalculator
{
public:
explicit RimSummaryCurveAppearanceCalculator(const std::set<std::pair<RimSummaryCase*, RifEclipseSummaryAddress> >& curveDefinitions);
explicit RimSummaryCurveAppearanceCalculator(const std::set<std::pair<RimSummaryCase*, RifEclipseSummaryAddress> >& curveDefinitions, const std::set<std::string> allSummaryCaseNames, const std::set<std::string> allSummaryWellNames);
enum CurveAppearanceType
{
NONE,
@@ -59,6 +59,8 @@ private:
void setOneCurveAppearance(CurveAppearanceType appeaType, size_t totalCount, int appeaIdx, RimSummaryCurve* curve);
void updateApperanceIndices();
std::map<std::string, size_t> mapNameToAppearanceIndex(CurveAppearanceType & appearance, const std::set<std::string>& names);
cvf::Color3f cycledPaletteColor(int colorIndex);
cvf::Color3f cycledNoneRGBBrColor(int colorIndex);
@@ -98,6 +100,9 @@ private:
std::map<char, std::map< std::string, int> > m_secondCharToVarToAppearanceIdxMap;
std::set<std::string> m_allSummaryCaseNames;
std::set<std::string> m_allSummaryWellNames;
};

45
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveAutoName.cpp
View File

@@ -47,10 +47,6 @@ RimSummaryCurveAutoName::RimSummaryCurveAutoName()
CAF_PDM_InitField(&m_completion, "Completion", true, "I, J, K", "", "", "");
CAF_PDM_InitField(&m_caseName, "CaseName", true, "Case Name", "", "", "");
CAF_PDM_InitField(&m_showAdvancedProperties, "ShowAdvancedProperties", false, "Show Advanced Properties", "", "", "");
m_showAdvancedProperties.uiCapability()->setUiEditorTypeName(caf::PdmUiPushButtonEditor::uiEditorTypeName());
m_showAdvancedProperties.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
}
//--------------------------------------------------------------------------------------------------
@@ -208,8 +204,6 @@ void RimSummaryCurveAutoName::applySettings(const RimSummaryCurveAutoName& other
m_wellSegmentNumber = other.m_wellSegmentNumber;
m_lgrName = other.m_lgrName;
m_completion = other.m_completion;
m_showAdvancedProperties = other.m_showAdvancedProperties;
}
//--------------------------------------------------------------------------------------------------
@@ -269,39 +263,14 @@ void RimSummaryCurveAutoName::defineUiOrdering(QString uiConfigName, caf::PdmUiO
uiOrdering.add(&m_wellGroupName);
uiOrdering.add(&m_wellName);
if (m_showAdvancedProperties)
{
uiOrdering.add(&m_regionNumber);
uiOrdering.add(&m_lgrName);
uiOrdering.add(&m_completion);
uiOrdering.add(&m_wellSegmentNumber);
uiOrdering.add(&m_unit);
}
uiOrdering.add(&m_showAdvancedProperties);
caf::PdmUiGroup& advanced = *(uiOrdering.addNewGroup("Advanced"));
advanced.setCollapsedByDefault(true);
advanced.add(&m_regionNumber);
advanced.add(&m_lgrName);
advanced.add(&m_completion);
advanced.add(&m_wellSegmentNumber);
advanced.add(&m_unit);
uiOrdering.skipRemainingFields();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveAutoName::defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute * attribute)
{
if (&m_showAdvancedProperties == field)
{
caf::PdmUiPushButtonEditorAttribute* attrib = dynamic_cast<caf::PdmUiPushButtonEditorAttribute*> (attribute);
if (attrib)
{
if (m_showAdvancedProperties)
{
attrib->m_buttonText = "Hide Advanced Options";
}
else
{
attrib->m_buttonText = "Show Advanced Options";
}
}
}
}

1
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveAutoName.h
View File

@@ -42,7 +42,6 @@ protected:
friend class RimSummaryCurveFilter;
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
virtual void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute * attribute);
private:
void appendWellName(std::string& text, const RifEclipseSummaryAddress& summaryAddress) const;

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

@@ -72,7 +72,7 @@ RimSummaryCurveFilter::RimSummaryCurveFilter()
m_selectedSummaryCases.uiCapability()->setAutoAddingOptionFromValue(false);
m_selectedSummaryCases.xmlCapability()->setIOWritable(false);
m_selectedSummaryCases.xmlCapability()->setIOReadable(false);
m_selectedSummaryCases.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::TOP);
m_selectedSummaryCases.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
CAF_PDM_InitFieldNoDefault(&m_summaryFilter, "VarListFilter", "Filter", "", "", "");
m_summaryFilter.uiCapability()->setUiTreeChildrenHidden(true);
@@ -91,12 +91,12 @@ RimSummaryCurveFilter::RimSummaryCurveFilter()
m_curves.uiCapability()->setUiHidden(true);
m_curves.uiCapability()->setUiTreeChildrenHidden(false);
CAF_PDM_InitFieldNoDefault(&m_applyButtonField, "ApplySelection", "Apply", "", "", "");
CAF_PDM_InitFieldNoDefault(&m_applyButtonField, "ApplySelection", "", "", "", "");
m_applyButtonField.xmlCapability()->setIOWritable(false);
m_applyButtonField.xmlCapability()->setIOReadable(false);
m_applyButtonField = false;
m_applyButtonField.uiCapability()->setUiEditorTypeName(caf::PdmUiPushButtonEditor::uiEditorTypeName());
m_applyButtonField.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
m_applyButtonField.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::LEFT);
CAF_PDM_InitField(&m_autoApplyChangesToPlot, "AutoApplyFilterChanges", false, "Auto Apply Changes", "", "", "");
@@ -189,27 +189,24 @@ QList<caf::PdmOptionItemInfo> RimSummaryCurveFilter::calculateValueOptions(const
//--------------------------------------------------------------------------------------------------
void RimSummaryCurveFilter::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup("Summary Vectors");
caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup("Cases");
curveDataGroup->add(&m_selectedSummaryCases);
caf::PdmUiGroup* curveVarSelectionGroup = curveDataGroup->addNewGroup("Vector Selection");
caf::PdmUiGroup* curveVarSelectionGroup = uiOrdering.addNewGroup("Vector Selection");
m_summaryFilter->uiOrdering(uiConfigName, *curveVarSelectionGroup);
curveVarSelectionGroup->add(&m_uiFilterResultMultiSelection);
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Appearance settings");
appearanceGroup->add(&m_useAutoAppearanceAssignment);
if(!m_useAutoAppearanceAssignment())
{
appearanceGroup->add(&m_caseAppearanceType);
appearanceGroup->add(&m_variableAppearanceType);
appearanceGroup->add(&m_wellAppearanceType);
appearanceGroup->add(&m_groupAppearanceType);
appearanceGroup->add(&m_regionAppearanceType);
}
uiOrdering.add(&m_plotAxis);
// Set sensitivity
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Appearance settings");
appearanceGroup->setCollapsedByDefault(true);
appearanceGroup->add(&m_useAutoAppearanceAssignment);
appearanceGroup->add(&m_caseAppearanceType);
appearanceGroup->add(&m_variableAppearanceType);
appearanceGroup->add(&m_wellAppearanceType);
appearanceGroup->add(&m_groupAppearanceType);
appearanceGroup->add(&m_regionAppearanceType);
// Appearance option sensitivity
{
m_caseAppearanceType.uiCapability()->setUiReadOnly(m_useAutoAppearanceAssignment);
m_variableAppearanceType.uiCapability()->setUiReadOnly(m_useAutoAppearanceAssignment);
@@ -219,11 +216,12 @@ void RimSummaryCurveFilter::defineUiOrdering(QString uiConfigName, caf::PdmUiOrd
}
caf::PdmUiGroup* autoNameGroup = uiOrdering.addNewGroup("Curve Name Configuration");
autoNameGroup->setCollapsedByDefault(true);
m_curveNameConfig->uiOrdering(uiConfigName, *autoNameGroup);
uiOrdering.add(&m_plotAxis);
uiOrdering.add(&m_autoApplyChangesToPlot);
uiOrdering.add(&m_applyButtonField);
m_applyButtonField.uiCapability()->setUiReadOnly(m_autoApplyChangesToPlot());
uiOrdering.skipRemainingFields(true);
}
@@ -513,7 +511,7 @@ void RimSummaryCurveFilter::createCurvesFromCurveDefinitions(const std::set<std:
{
RimSummaryCase* prevCase = nullptr;
RimPlotCurve::LineStyleEnum lineStyle = RimPlotCurve::STYLE_SOLID;
RimSummaryCurveAppearanceCalculator curveLookCalc(curveDefinitions);
RimSummaryCurveAppearanceCalculator curveLookCalc(curveDefinitions, getAllSummaryCaseNames(), getAllSummaryWellNames());
if (!m_useAutoAppearanceAssignment())
{
@@ -658,3 +656,57 @@ std::set<RifEclipseSummaryAddress> RimSummaryCurveFilter::findPossibleSummaryAdd
return addrUnion;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<std::string> RimSummaryCurveFilter::getAllSummaryCaseNames()
{
std::set<std::string> summaryCaseHashes;
RimProject* proj = RiaApplication::instance()->project();
std::vector<RimSummaryCase*> cases;
proj->allSummaryCases(cases);
for (RimSummaryCase* rimCase : cases)
{
summaryCaseHashes.insert(rimCase->summaryHeaderFilename().toUtf8().constData());
}
return summaryCaseHashes;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::set<std::string> RimSummaryCurveFilter::getAllSummaryWellNames()
{
std::set<std::string> summaryWellNames;
RimProject* proj = RiaApplication::instance()->project();
std::vector<RimSummaryCase*> cases;
proj->allSummaryCases(cases);
for (RimSummaryCase* rimCase : cases)
{
RifReaderEclipseSummary* reader = nullptr;
if (rimCase && rimCase->caseData())
{
reader = rimCase->caseData()->summaryReader();
}
if (reader)
{
const std::vector<RifEclipseSummaryAddress> allAddresses = reader->allResultAddresses();
for (size_t i = 0; i < allAddresses.size(); i++)
{
if (allAddresses[i].category() == RifEclipseSummaryAddress::SUMMARY_WELL)
{
summaryWellNames.insert(allAddresses[i].wellName());
}
}
}
}
return summaryWellNames;
}

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

@@ -98,6 +98,9 @@ private:
void updatePlotAxisForCurves();
void loadDataAndUpdatePlot();
std::set<std::string> getAllSummaryCaseNames();
std::set<std::string> getAllSummaryWellNames();
private:
QPointer<QwtPlot> m_parentQwtPlot;

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

@@ -203,6 +203,8 @@ QString RimSummaryPlot::asciiDataForPlotExport() const
{
QString out;
out += description();
{
std::vector<RimSummaryCurve*> curves;
this->descendantsIncludingThisOfType(curves);

12
ApplicationCode/ProjectDataModel/Summary/RimSummaryTimeAxisProperties.cpp
View File

@@ -283,11 +283,13 @@ double RimSummaryTimeAxisProperties::fromTimeTToDisplayUnitScale()
//--------------------------------------------------------------------------------------------------
void RimSummaryTimeAxisProperties::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
uiOrdering.add(&showTitle);
uiOrdering.add(&title);
uiOrdering.add(&titlePositionEnum);
uiOrdering.add(&fontSize);
caf::PdmUiGroup* timeGroup = uiOrdering.addNewGroup("Time");
caf::PdmUiGroup& titleGroup = *(uiOrdering.addNewGroup("Axis Title"));
titleGroup.add(&showTitle);
titleGroup.add(&title);
titleGroup.add(&titlePositionEnum);
titleGroup.add(&fontSize);
caf::PdmUiGroup* timeGroup = uiOrdering.addNewGroup("Time Values");
timeGroup->add(&m_timeMode);
if (m_timeMode() == DATE)
{

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

@@ -113,6 +113,25 @@ QList<caf::PdmOptionItemInfo> RimSummaryYAxisProperties::calculateValueOptions(c
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSummaryYAxisProperties::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup& titleGroup = *(uiOrdering.addNewGroup("Axis Title"));
titleGroup.add(&isAutoTitle);
titleGroup.add(&customTitle);
titleGroup.add(&titlePositionEnum);
titleGroup.add(&fontSize);
caf::PdmUiGroup& scaleGroup = *(uiOrdering.addNewGroup("Axis Values"));
scaleGroup.add(&isLogarithmicScaleEnabled);
scaleGroup.add(&numberFormat);
scaleGroup.add(&visibleRangeMin);
scaleGroup.add(&visibleRangeMax);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/ProjectDataModel/Summary/RimSummaryYAxisProperties.h
View File

@@ -81,6 +81,7 @@ protected:
virtual caf::PdmFieldHandle* objectToggleField() override;
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
private:
void updateOptionSensitivity();