OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-01-08 07:03:25 -06:00
Code Issues Packages Projects Releases Wiki Activity
bd1fbcf45a
ResInsight/ApplicationLibCode/ProjectDataModel/RimSimWellInViewCollection.cpp
Magne Sjaastad 40080a99de
9978 Improve UI for long drop-down lists, use tree selection more 
* Improve tree selection editor
- always call defineEditorAttributes
- use heightHint in editor attributes 
- use tree selection editor as default editor for std::vector

* Use tree selection editor instead of list selection editor
List selection editor must be used when editing std::vector<cvf::vec3d> and similar. Replace other use of list selection editor with tree selection editor.

* Set checked state based on text string for integer only models
For models with only integer values, use text string to define the items to be selected. The full list will always be visible, and the checked state will be updated when editing the filter text.

Example: "1, 5-7" will set items 1, 5, 6, 7 checked and all other items unchecked

* Minor fixes
- Set placeholder text after content is added (to ensure correct data type)
- Fix check of integers. `canConvert<int>()`returns true for both QString and int. Thus convert to string and then check for int conversion.

* Activate filtering when unchecking all items in list with only integers
- Reactivate filtering when uncheck of all items for a list with only integer values (to keep consistency between filter and list)
- Update function name for clarity

---------

Co-authored-by: Jørgen Herje <jorgen.herje@ceetronsolutions.com>
2023-05-22 15:44:37 +02:00

1007 lines
39 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2011- Statoil ASA
// Copyright (C) 2013- Ceetron Solutions AS
// Copyright (C) 2011-2012 Ceetron AS
//
// 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 "RimSimWellInViewCollection.h"
#include "RiaFieldHandleTools.h"
#include "RiaPreferences.h"
#include "RigEclipseCaseData.h"
#include "RigSimWellData.h"
#include "RigWellResultFrame.h"
#include "RimEclipseCase.h"
#include "RimEclipseContourMapView.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseView.h"
#include "RimIntersectionCollection.h"
#include "RimProject.h"
#include "RimSimWellFractureCollection.h"
#include "RimSimWellInView.h"
#include "RimSimWellInViewTools.h"
#include "RimSummaryCase.h"
#include "RimVirtualPerforationResults.h"
#include "RimWellAllocationPlot.h"
#include "RimWellDiskConfig.h"
#include "RifSummaryReaderInterface.h"
#include "RiuMainWindow.h"
#include "RiuSummaryQuantityNameInfoProvider.h"
#include "RivReservoirViewPartMgr.h"
#include "cafPdmUiCheckBoxTristateEditor.h"
#include "cafPdmUiPushButtonEditor.h"
#include "cafPdmUiTreeOrdering.h"
#include "cafPdmUiTreeSelectionEditor.h"
#include <set>
namespace caf
{
template <>
void RimSimWellInViewCollection::WellFenceEnum::setUp()
{
addItem( RimSimWellInViewCollection::K_DIRECTION, "K_DIRECTION", "K - Direction" );
addItem( RimSimWellInViewCollection::J_DIRECTION, "J_DIRECTION", "J - Direction" );
addItem( RimSimWellInViewCollection::I_DIRECTION, "I_DIRECTION", "I - Direction" );
setDefault( RimSimWellInViewCollection::K_DIRECTION );
}
} // namespace caf
namespace caf
{
template <>
void RimSimWellInViewCollection::WellHeadPositionEnum::setUp()
{
addItem( RimSimWellInViewCollection::WELLHEAD_POS_ACTIVE_CELLS_BB, "WELLHEAD_POS_ACTIVE_CELLS_BB", "Top of Active Cells" );
addItem( RimSimWellInViewCollection::WELLHEAD_POS_TOP_COLUMN, "WELLHEAD_POS_TOP_COLUMN", "Top of Active Cell Column" );
setDefault( RimSimWellInViewCollection::WELLHEAD_POS_TOP_COLUMN );
}
} // namespace caf
namespace caf
{
template <>
void RimSimWellInViewCollection::WellPipeCoordEnum::setUp()
{
addItem( RimSimWellInViewCollection::WELLPIPE_INTERPOLATED, "WELLPIPE_INTERPOLATED", "Interpolated" );
addItem( RimSimWellInViewCollection::WELLPIPE_CELLCENTER, "WELLPIPE_CELLCENTER", "Cell Centers" );
setDefault( RimSimWellInViewCollection::WELLPIPE_INTERPOLATED );
}
} // namespace caf
namespace caf
{
template <>
void RimSimWellInViewCollection::WellPipeColorsEnum::setUp()
{
addItem( RimSimWellInViewCollection::WELLPIPE_COLOR_UNIQUE, "WELLPIPE_COLOR_INDIDUALLY", "Unique Colors" );
addItem( RimSimWellInViewCollection::WELLPIPE_COLOR_UNIFORM, "WELLPIPE_COLOR_UNIFORM", "Uniform Default Color" );
setDefault( RimSimWellInViewCollection::WELLPIPE_COLOR_UNIQUE );
}
} // namespace caf
namespace caf
{
template <>
void AppEnum<RimSimWellInViewCollection::WellDiskPropertyType>::setUp()
{
addItem( RimSimWellInViewCollection::PROPERTY_TYPE_PREDEFINED, " PROPERTY_TYPE_PREDEFINED", "Predefined" );
addItem( RimSimWellInViewCollection::PROPERTY_TYPE_SINGLE, "ANY_SINGLE_PROPERTY", "Single Property" );
setDefault( RimSimWellInViewCollection::PROPERTY_TYPE_PREDEFINED );
}
} // namespace caf
namespace caf
{
template <>
void AppEnum<RimSimWellInViewCollection::WellDiskPropertyConfigType>::setUp()
{
addItem( RimSimWellInViewCollection::PRODUCTION_RATES, "PRODUCTION_RATES", "Production Rates" );
addItem( RimSimWellInViewCollection::INJECTION_RATES, "INJECTION_RATES", "Injection Rates" );
addItem( RimSimWellInViewCollection::CUMULATIVE_PRODUCTION_RATES, "CUMULATIVE_PRODUCTION_RATES", "Production Total" );
addItem( RimSimWellInViewCollection::CUMULATIVE_INJECTION_RATES, "CUMULATIVE_INJECTION_RATES", "Injection Total" );
addItem( RimSimWellInViewCollection::PRODUCTION_INJECTION_RATES, "PRODUCTION_INJECTION_RATES", "Production/Injection Rates" );
addItem( RimSimWellInViewCollection::CUMULATIVE_PRODUCTION_INJECTION_RATES,
"CUMULATIVE_PRODUCTION_INJECTION_RATES",
"Production/Injection Total" );
setDefault( RimSimWellInViewCollection::PRODUCTION_RATES );
}
} // namespace caf
CAF_PDM_SOURCE_INIT( RimSimWellInViewCollection, "Wells" );
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSimWellInViewCollection::RimSimWellInViewCollection()
{
CAF_PDM_InitObject( "Simulation Wells", ":/WellCollection.png" );
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, "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" );
CAF_PDM_InitFieldNoDefault( &m_showWellLabel, "ShowWellLabelTristate", "Label" );
CAF_PDM_InitFieldNoDefault( &m_showWellPipe, "ShowWellPipe", "Pipe" );
CAF_PDM_InitFieldNoDefault( &m_showWellSpheres, "ShowWellSpheres", "Spheres" );
CAF_PDM_InitFieldNoDefault( &m_showWellDisks, "ShowWellDisks", "Disks" );
m_showWellHead.uiCapability()->setUiEditorTypeName( caf::PdmUiCheckBoxTristateEditor::uiEditorTypeName() );
m_showWellHead.xmlCapability()->disableIO();
m_showWellLabel.uiCapability()->setUiEditorTypeName( caf::PdmUiCheckBoxTristateEditor::uiEditorTypeName() );
m_showWellLabel.xmlCapability()->disableIO();
m_showWellPipe.uiCapability()->setUiEditorTypeName( caf::PdmUiCheckBoxTristateEditor::uiEditorTypeName() );
m_showWellPipe.xmlCapability()->disableIO();
m_showWellSpheres.uiCapability()->setUiEditorTypeName( caf::PdmUiCheckBoxTristateEditor::uiEditorTypeName() );
m_showWellSpheres.xmlCapability()->disableIO();
m_showWellDisks.uiCapability()->setUiEditorTypeName( caf::PdmUiCheckBoxTristateEditor::uiEditorTypeName() );
m_showWellDisks.xmlCapability()->disableIO();
// Scaling
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 = RiaPreferences::current()->defaultWellLabelColor();
CAF_PDM_InitField( &wellLabelColor, "WellLabelColor", defWellLabelColor, "Label Color" );
CAF_PDM_InitField( &showConnectionStatusColors, "ShowConnectionStatusColors", true, "Color Pipe Connections" );
cvf::Color3f defaultApplyColor = cvf::Color3f::YELLOW;
CAF_PDM_InitField( &m_defaultWellPipeColor, "WellColorForApply", defaultApplyColor, "Uniform Well Color" );
CAF_PDM_InitFieldNoDefault( &m_wellPipeColors, "WellPipeColors", "Individual Pipe Colors" );
CAF_PDM_InitField( &pipeCrossSectionVertexCount, "WellPipeVertexCount", 12, "Pipe Vertex Count" );
pipeCrossSectionVertexCount.uiCapability()->setUiHidden( true );
CAF_PDM_InitField( &wellPipeCoordType, "WellPipeCoordType", WellPipeCoordEnum( WELLPIPE_INTERPOLATED ), "Type" );
CAF_PDM_InitFieldNoDefault( &m_showWellCells, "ShowWellCellsTristate", "Show Well Cells" );
m_showWellCells.uiCapability()->setUiEditorTypeName( caf::PdmUiCheckBoxTristateEditor::uiEditorTypeName() );
m_showWellCells.xmlCapability()->disableIO();
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 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()->setUiTreeHidden( true );
CAF_PDM_InitFieldNoDefault( &m_showWellCellFence, "ShowWellCellFenceTristate", "Show Well Cell Fence" );
m_showWellCellFence.uiCapability()->setUiEditorTypeName( caf::PdmUiCheckBoxTristateEditor::uiEditorTypeName() );
m_showWellCellFence.xmlCapability()->disableIO();
CAF_PDM_InitField( &m_showWellValves, "ShowWellValvesTristate", true, "Valves" );
CAF_PDM_InitFieldNoDefault( &m_wellDiskSummaryCase, "WellDiskSummaryCase", "Summary Case" );
CAF_PDM_InitField( &m_wellDiskQuantity, "WellDiskQuantity", QString( "WOPT" ), "Disk Quantity" );
m_wellDiskQuantity.uiCapability()->setUiEditorTypeName( caf::PdmUiTreeSelectionEditor::uiEditorTypeName() );
m_wellDiskQuantity.uiCapability()->setAutoAddingOptionFromValue( false );
CAF_PDM_InitFieldNoDefault( &m_wellDiskPropertyType, "WellDiskPropertyType", "Property Type" );
CAF_PDM_InitFieldNoDefault( &m_wellDiskPropertyConfigType, "WellDiskPropertyConfigType", "Property Config Type" );
CAF_PDM_InitField( &m_wellDiskShowQuantityLabels, "WellDiskShowQuantityLabels", true, "Show Quantity Labels" );
CAF_PDM_InitField( &m_wellDiskshowLabelsBackground, "WellDiskShowLabelsBackground", false, "Show Label Background" );
CAF_PDM_InitField( &m_wellDiskScaleFactor, "WellDiskScaleFactor", 1.0, "Scale Factor" );
cvf::Color3f defaultWellDiskColor = cvf::Color3::OLIVE;
CAF_PDM_InitField( &wellDiskColor, "WellDiskColor", defaultWellDiskColor, "Well Disk Color" );
CAF_PDM_InitField( &m_showWellCommunicationLines, "ShowWellCommunicationLines", false, "Communication Lines" );
m_reservoirView = nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSimWellInViewCollection::~RimSimWellInViewCollection()
{
wells.deleteChildren();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::setShowWellCellsState( bool enable )
{
for ( RimSimWellInView* w : wells )
{
w->showWellCells = enable;
}
updateConnectedEditors();
if ( m_reservoirView )
{
m_reservoirView->scheduleGeometryRegen( VISIBLE_WELL_CELLS );
m_reservoirView->scheduleCreateDisplayModelAndRedraw();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSimWellInViewCollection::showWellCells()
{
if ( m_showWellCells().isFalse() )
{
return false;
}
else
{
return true;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSimWellInView* RimSimWellInViewCollection::findWell( QString name )
{
for ( size_t i = 0; i < this->wells().size(); ++i )
{
if ( this->wells()[i]->name() == name )
{
return this->wells()[i];
}
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSimWellInViewCollection::hasVisibleWellCells()
{
if ( !this->isActive() ) return false;
if ( this->wells().size() == 0 ) return false;
bool hasCells = false;
for ( size_t i = 0; !hasCells && i < this->wells().size(); ++i )
{
RimSimWellInView* well = this->wells()[i];
if ( well && well->simWellData() && ( ( well->showWell() && well->showWellCells() ) ) )
{
for ( size_t tIdx = 0; !hasCells && tIdx < well->simWellData()->m_wellCellsTimeSteps.size(); ++tIdx )
{
const RigWellResultFrame& wellResultFrame = well->simWellData()->m_wellCellsTimeSteps[tIdx];
for ( size_t wsIdx = 0; !hasCells && wsIdx < wellResultFrame.wellResultBranches().size(); ++wsIdx )
{
if ( !wellResultFrame.branchResultPointsFromBranchIndex( wsIdx ).empty() ) hasCells = true;
}
}
}
}
if ( !hasCells ) return false;
// Todo: Handle range filter intersection
return true;
}
//--------------------------------------------------------------------------------------------------
/// Used to know if we need animation of time steps due to the wells
//--------------------------------------------------------------------------------------------------
bool RimSimWellInViewCollection::hasVisibleWellPipes()
{
if ( !this->isActive() ) return false;
if ( this->wells().size() == 0 ) return false;
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
{
if ( &isActive == changedField )
{
this->updateUiIconFromToggleField();
}
if ( &m_showWellLabel == changedField )
{
for ( RimSimWellInView* w : wells )
{
w->showWellLabel = !( m_showWellLabel().isFalse() );
w->updateConnectedEditors();
}
}
if ( &m_showWellHead == changedField )
{
for ( RimSimWellInView* w : wells )
{
w->showWellHead = !( m_showWellHead().isFalse() );
w->updateConnectedEditors();
}
}
if ( &m_showWellPipe == changedField )
{
for ( RimSimWellInView* w : wells )
{
w->showWellPipe = !( m_showWellPipe().isFalse() );
w->updateConnectedEditors();
}
}
if ( &m_showWellSpheres == changedField )
{
for ( RimSimWellInView* w : wells )
{
w->showWellSpheres = !( m_showWellSpheres().isFalse() );
w->updateConnectedEditors();
}
}
if ( &m_showWellDisks == changedField )
{
for ( RimSimWellInView* w : wells )
{
w->showWellDisks = !( m_showWellDisks().isFalse() );
w->updateConnectedEditors();
}
}
if ( &m_showWellCells == changedField )
{
for ( RimSimWellInView* w : wells )
{
w->showWellCells = !( m_showWellCells().isFalse() );
w->updateConnectedEditors();
}
}
if ( &m_showWellCellFence == changedField )
{
for ( RimSimWellInView* w : wells )
{
w->showWellCellFence = !( m_showWellCellFence().isFalse() );
w->updateConnectedEditors();
}
}
if ( &wellDiskColor == changedField )
{
for ( RimSimWellInView* w : wells )
{
w->wellDiskColor = wellDiskColor;
w->updateConnectedEditors();
}
}
if ( m_reservoirView )
{
if ( !m_wellDiskSummaryCase() )
{
setDefaultSourceCaseForWellDisks();
}
if ( &isActive == changedField || &m_showWellCells == changedField || &m_showWellCellFence == changedField ||
&wellCellFenceType == changedField || &showWellsIntersectingVisibleCells == changedField )
{
m_reservoirView->scheduleGeometryRegen( VISIBLE_WELL_CELLS );
m_reservoirView->scheduleCreateDisplayModelAndRedraw();
}
else if ( &wellCellTransparencyLevel == changedField )
{
m_reservoirView->scheduleCreateDisplayModelAndRedraw();
}
else if ( &m_wellDiskQuantity == changedField || &m_wellDiskPropertyType == changedField ||
&m_wellDiskPropertyConfigType == changedField || &m_wellDiskshowLabelsBackground == changedField ||
&m_wellDiskShowQuantityLabels == changedField || &m_wellDiskSummaryCase == changedField ||
&m_wellDiskScaleFactor == changedField || &wellDiskColor == changedField || &m_showWellDisks == changedField ||
&m_showWellLabel == changedField )
{
m_reservoirView->updateDisplayModelForCurrentTimeStepAndRedraw();
}
else if ( &spheresScaleFactor == changedField || &m_showWellSpheres == changedField ||
&showConnectionStatusColors == changedField || &m_showWellValves == changedField )
{
m_reservoirView->scheduleSimWellGeometryRegen();
m_reservoirView->scheduleCreateDisplayModelAndRedraw();
}
else if ( &pipeCrossSectionVertexCount == changedField || &pipeScaleFactor == changedField || &wellHeadScaleFactor == changedField ||
&m_showWellHead == changedField || &isAutoDetectingBranches == changedField || &wellHeadPosition == changedField ||
&wellLabelColor == changedField || &wellPipeCoordType == changedField || &m_showWellPipe == changedField )
{
m_reservoirView->scheduleSimWellGeometryRegen();
m_reservoirView->scheduleCreateDisplayModelAndRedraw();
for ( RimSimWellInView* w : wells )
w->schedule2dIntersectionViewUpdate();
}
}
if ( &m_wellPipeColors == changedField || &m_defaultWellPipeColor == changedField )
{
if ( m_wellPipeColors == WELLPIPE_COLOR_UNIQUE )
{
assignDefaultWellColors();
}
else
{
cvf::Color3f col = m_defaultWellPipeColor();
for ( size_t i = 0; i < wells.size(); i++ )
{
wells[i]->wellPipeColor = col;
wells[i]->updateConnectedEditors();
}
RimSimWellInViewCollection::updateWellAllocationPlots();
}
if ( m_reservoirView ) m_reservoirView->scheduleCreateDisplayModelAndRedraw();
}
if ( &m_showWellCells == changedField )
{
RiuMainWindow::instance()->refreshDrawStyleActions();
}
if ( &m_showWellCommunicationLines == changedField )
{
if ( m_reservoirView ) m_reservoirView->scheduleCreateDisplayModelAndRedraw();
}
if ( &wellPipeCoordType == changedField || &isAutoDetectingBranches == changedField )
{
if ( m_reservoirView )
{
m_reservoirView->intersectionCollection()->recomputeSimWellBranchData();
}
for ( RimSimWellInView* w : wells )
{
w->simwellFractureCollection()->recomputeSimWellCenterlines();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RimSimWellInViewCollection::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions )
{
QList<caf::PdmOptionItemInfo> options;
if ( fieldNeedingOptions == &m_wellDiskQuantity )
{
auto summaryCase = m_wellDiskSummaryCase();
if ( summaryCase )
{
std::set<std::string> summaries;
if ( summaryCase && summaryCase->summaryReader() )
{
auto addresses = summaryCase->summaryReader()->allResultAddresses();
for ( auto addr : addresses )
{
if ( addr.category() == RifEclipseSummaryAddress::SUMMARY_WELL )
{
summaries.insert( addr.vectorName() );
}
}
}
for ( const auto& itemName : summaries )
{
QString displayName;
std::string longVectorName = RiuSummaryQuantityNameInfoProvider::instance()->longNameFromVectorName( itemName );
if ( longVectorName.empty() )
{
displayName = QString::fromStdString( itemName );
}
else
{
displayName = QString::fromStdString( longVectorName );
displayName += QString( " (%1)" ).arg( QString::fromStdString( itemName ) );
}
auto optionItem = caf::PdmOptionItemInfo( displayName, QString::fromStdString( itemName ) );
options.push_back( optionItem );
}
}
}
else if ( fieldNeedingOptions == &m_wellDiskSummaryCase )
{
auto cases = RimSimWellInViewTools::summaryCases();
for ( auto c : cases )
{
auto optionItem = caf::PdmOptionItemInfo( c->displayCaseName(), c );
options.push_back( optionItem );
}
}
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= "" */ )
{
if ( m_reservoirView && m_reservoirView->virtualPerforationResult() )
{
auto uiTree = m_reservoirView->virtualPerforationResult()->uiTreeOrdering( uiConfigName );
uiTreeOrdering.appendChild( uiTree );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::assignDefaultWellColors()
{
auto ownerCase = firstAncestorOrThisOfTypeAsserted<RimEclipseCase>();
for ( size_t wIdx = 0; wIdx < wells.size(); ++wIdx )
{
RimSimWellInView* well = wells[wIdx];
if ( well && well->simWellData() )
{
well->wellPipeColor = ownerCase->defaultWellColor( well->simWellData()->m_wellName );
}
}
RimSimWellInViewCollection::updateWellAllocationPlots();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::updateWellAllocationPlots()
{
RimProject* proj = RimProject::current();
std::vector<RimWellAllocationPlot*> wellAllocationPlots = proj->descendantsIncludingThisOfType<RimWellAllocationPlot>();
for ( auto wap : wellAllocationPlots )
{
wap->loadDataAndUpdate();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::setDefaultSourceCaseForWellDisks()
{
if ( m_wellDiskSummaryCase == nullptr && !wells.empty() )
{
m_wellDiskSummaryCase = RimSimWellInViewTools::summaryCaseForWell( wells[0] );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::setReservoirView( RimEclipseView* ownerReservoirView )
{
m_reservoirView = ownerReservoirView;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{
updateStateForVisibilityCheckboxes();
bool isContourMap = dynamic_cast<const RimEclipseContourMapView*>( m_reservoirView ) != nullptr;
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup( "Visibility" );
if ( !isContourMap )
{
appearanceGroup->add( &showWellsIntersectingVisibleCells );
}
appearanceGroup->add( &m_showWellLabel );
appearanceGroup->add( &m_showWellHead );
appearanceGroup->add( &m_showWellPipe );
appearanceGroup->add( &m_showWellSpheres );
appearanceGroup->add( &m_showWellDisks );
appearanceGroup->add( &m_showWellCommunicationLines );
appearanceGroup->add( &m_showWellValves );
if ( !isContourMap )
{
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( "Colors" );
colorGroup->setCollapsedByDefault();
colorGroup->add( &showConnectionStatusColors );
colorGroup->add( &wellLabelColor );
colorGroup->add( &m_wellPipeColors );
if ( m_wellPipeColors == WELLPIPE_COLOR_UNIFORM )
{
colorGroup->add( &m_defaultWellPipeColor );
}
caf::PdmUiGroup* wellPipeGroup = uiOrdering.addNewGroup( "Well Pipe Geometry" );
wellPipeGroup->add( &wellPipeCoordType );
wellPipeGroup->add( &isAutoDetectingBranches );
if ( !isContourMap )
{
caf::PdmUiGroup* advancedGroup = uiOrdering.addNewGroup( "Advanced" );
advancedGroup->setCollapsedByDefault();
advancedGroup->add( &wellCellTransparencyLevel );
advancedGroup->add( &wellHeadPosition );
}
{
caf::PdmUiGroup* wellDiskGroup = uiOrdering.addNewGroup( "Disks" );
if ( !m_wellDiskSummaryCase() )
{
setDefaultSourceCaseForWellDisks();
}
wellDiskGroup->add( &m_wellDiskSummaryCase );
wellDiskGroup->add( &m_wellDiskPropertyType );
if ( m_wellDiskPropertyType() == PROPERTY_TYPE_PREDEFINED )
{
wellDiskGroup->add( &m_wellDiskPropertyConfigType );
}
else
{
wellDiskGroup->add( &m_wellDiskQuantity );
}
wellDiskGroup->add( &m_wellDiskShowQuantityLabels );
wellDiskGroup->add( &m_wellDiskshowLabelsBackground );
wellDiskGroup->add( &m_wellDiskScaleFactor );
if ( m_wellDiskPropertyType() == PROPERTY_TYPE_SINGLE )
{
wellDiskGroup->add( &wellDiskColor );
}
bool isReadOnly = m_showWellDisks().isFalse();
m_wellDiskPropertyType.uiCapability()->setUiReadOnly( isReadOnly );
m_wellDiskPropertyConfigType.uiCapability()->setUiReadOnly( isReadOnly );
m_wellDiskSummaryCase.uiCapability()->setUiReadOnly( isReadOnly );
m_wellDiskQuantity.uiCapability()->setUiReadOnly( isReadOnly );
m_wellDiskShowQuantityLabels.uiCapability()->setUiReadOnly( isReadOnly );
m_wellDiskshowLabelsBackground.uiCapability()->setUiReadOnly( isReadOnly );
m_wellDiskScaleFactor.uiCapability()->setUiReadOnly( isReadOnly );
wellDiskColor.uiCapability()->setUiReadOnly( isReadOnly );
}
auto ownerCase = firstAncestorOrThisOfType<RimEclipseResultCase>();
if ( ownerCase )
{
m_showWellCommunicationLines.uiCapability()->setUiHidden( !ownerCase->flowDiagSolverInterface() );
}
m_showWellCellFence.uiCapability()->setUiReadOnly( !showWellCells() );
wellCellFenceType.uiCapability()->setUiReadOnly( !showWellCells() );
uiOrdering.skipRemainingFields( true );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::updateStateForVisibilityCheckboxes()
{
size_t showLabelCount = 0;
size_t showWellHeadCount = 0;
size_t showPipeCount = 0;
size_t showSphereCount = 0;
size_t showDiskCount = 0;
size_t showWellCellsCount = 0;
size_t showWellCellFenceCount = 0;
for ( RimSimWellInView* w : wells )
{
if ( w->showWellLabel() ) showLabelCount++;
if ( w->showWellHead() ) showWellHeadCount++;
if ( w->showWellPipe() ) showPipeCount++;
if ( w->showWellSpheres() ) showSphereCount++;
if ( w->showWellDisks() ) showDiskCount++;
if ( w->showWellCells() ) showWellCellsCount++;
if ( w->showWellCellFence() ) showWellCellFenceCount++;
}
updateStateFromEnabledChildCount( showLabelCount, &m_showWellLabel );
updateStateFromEnabledChildCount( showWellHeadCount, &m_showWellHead );
updateStateFromEnabledChildCount( showPipeCount, &m_showWellPipe );
updateStateFromEnabledChildCount( showSphereCount, &m_showWellSpheres );
updateStateFromEnabledChildCount( showDiskCount, &m_showWellDisks );
updateStateFromEnabledChildCount( showWellCellsCount, &m_showWellCells );
updateStateFromEnabledChildCount( showWellCellFenceCount, &m_showWellCellFence );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::updateStateFromEnabledChildCount( size_t enabledChildCount, caf::PdmField<caf::Tristate>* fieldToUpdate )
{
caf::Tristate tristate;
if ( enabledChildCount == 0 )
{
tristate = caf::Tristate::State::False;
}
else if ( enabledChildCount == wells.size() )
{
tristate = caf::Tristate::State::True;
}
else
{
tristate = caf::Tristate::State::PartiallyTrue;
}
fieldToUpdate->setValue( tristate );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
caf::PdmFieldHandle* RimSimWellInViewCollection::objectToggleField()
{
return &isActive;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<cvf::ubyte>& RimSimWellInViewCollection::resultWellGeometryVisibilities( size_t frameIndex )
{
calculateWellGeometryVisibility( frameIndex );
return m_framesOfResultWellPipeVisibilities[frameIndex];
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::scheduleIsWellPipesVisibleRecalculation()
{
m_framesOfResultWellPipeVisibilities.clear();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::calculateWellGeometryVisibility( size_t frameIndex )
{
if ( m_framesOfResultWellPipeVisibilities.size() > frameIndex && m_framesOfResultWellPipeVisibilities[frameIndex].size() ) return;
if ( m_framesOfResultWellPipeVisibilities.size() <= frameIndex ) m_framesOfResultWellPipeVisibilities.resize( frameIndex + 1 );
if ( m_framesOfResultWellPipeVisibilities[frameIndex].size() <= wells().size() )
m_framesOfResultWellPipeVisibilities[frameIndex].resize( wells().size(), false );
for ( const RimSimWellInView* well : wells() )
{
bool wellPipeVisible = well->isWellPipeVisible( frameIndex );
bool wellSphereVisible = well->isWellSpheresVisible( frameIndex );
m_framesOfResultWellPipeVisibilities[frameIndex][well->resultWellIndex()] = wellPipeVisible || wellSphereVisible;
}
}
bool lessEclipseWell( const caf::PdmPointer<RimSimWellInView>& w1, const caf::PdmPointer<RimSimWellInView>& w2 )
{
if ( w1.notNull() && w2.notNull() )
return ( w1->name() < w2->name() );
else if ( w1.notNull() )
return true;
else
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::sortWellsByName()
{
std::sort( wells.begin(), wells.end(), lessEclipseWell );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimSimWellInViewCollection::wellDiskPropertyUiText() const
{
if ( m_wellDiskPropertyType() == RimSimWellInViewCollection::PROPERTY_TYPE_PREDEFINED )
{
return m_wellDiskPropertyConfigType().uiText();
}
return m_wellDiskQuantity;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSimWellInViewCollection::isWellDisksVisible() const
{
return m_showWellDisks.v().isTrue() || m_showWellDisks.v().isPartiallyTrue();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSimWellInViewCollection::showWellDiskLabelBackground() const
{
return m_wellDiskshowLabelsBackground();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSimWellInViewCollection::showWellDiskQuantityLables() const
{
return m_wellDiskShowQuantityLabels();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::scaleWellDisks()
{
if ( !isActive ) return;
if ( m_showWellDisks().isFalse() ) return;
RimWellDiskConfig wellDiskConfig = getActiveWellDiskConfig();
scaleWellDisksFromConfig( wellDiskConfig );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSimWellInViewCollection::scaleWellDisksFromConfig( const RimWellDiskConfig& wellDiskConfig )
{
double minValue = std::numeric_limits<double>::max();
double maxValue = -minValue;
for ( RimSimWellInView* w : wells )
{
if ( !w->isWellDiskVisible() ) continue;
bool isOk = true;
double value = w->calculateInjectionProductionFractions( wellDiskConfig, &isOk );
if ( isOk )
{
minValue = std::min( minValue, value );
maxValue = std::max( maxValue, value );
}
}
if ( maxValue > minValue )
{
for ( RimSimWellInView* w : wells )
{
w->scaleDisk( minValue, maxValue );
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RimSimWellInViewCollection::wellDiskScaleFactor() const
{
return m_wellDiskScaleFactor();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSimWellInViewCollection::showValves() const
{
return m_showWellValves();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellDiskConfig RimSimWellInViewCollection::getActiveWellDiskConfig() const
{
RimWellDiskConfig wellDiskConfig;
wellDiskConfig.setSourceCase( m_wellDiskSummaryCase() );
if ( m_wellDiskPropertyType() == RimSimWellInViewCollection::PROPERTY_TYPE_PREDEFINED )
{
WellDiskPropertyConfigType configType = m_wellDiskPropertyConfigType();
if ( configType == PRODUCTION_RATES )
{
wellDiskConfig.setOilProperty( "WOPR" );
wellDiskConfig.setGasProperty( "WGPR" );
wellDiskConfig.setWaterProperty( "WWPR" );
}
else if ( configType == INJECTION_RATES )
{
wellDiskConfig.setOilProperty( "" );
wellDiskConfig.setGasProperty( "WGIR" );
wellDiskConfig.setWaterProperty( "WWIR" );
}
else if ( configType == CUMULATIVE_PRODUCTION_RATES )
{
wellDiskConfig.setOilProperty( "WOPT" );
wellDiskConfig.setGasProperty( "WGPT" );
wellDiskConfig.setWaterProperty( "WWPT" );
}
else if ( configType == CUMULATIVE_INJECTION_RATES )
{
wellDiskConfig.setOilProperty( "" );
wellDiskConfig.setGasProperty( "WGIT" );
wellDiskConfig.setWaterProperty( "WWIT" );
}
else if ( configType == PRODUCTION_INJECTION_RATES )
{
wellDiskConfig.setOilProperty( "WOPR", "" );
wellDiskConfig.setGasProperty( "WGPR", "WGIR" );
wellDiskConfig.setWaterProperty( "WWPR", "WWIR" );
}
else if ( configType == CUMULATIVE_PRODUCTION_INJECTION_RATES )
{
wellDiskConfig.setOilProperty( "WOPT", "" );
wellDiskConfig.setGasProperty( "WGPT", "WGIT" );
wellDiskConfig.setWaterProperty( "WWPT", "WWIT" );
}
}
else
{
wellDiskConfig.setSingleProperty( m_wellDiskQuantity.v().toStdString() );
}
return wellDiskConfig;
}
Reference in New Issue View Git Blame Copy Permalink