mirror of
https://github.com/OPM/ResInsight.git
synced 2026-10-25 06:38:13 -05:00
Kristian Bendiksen
417e515d3d
The boundary conditions table required several clicks in each cell before a value could be changed, because the table view used Qt's default edit triggers. Add an opt-in editOnSingleClick attribute to the table view editor that starts editing on a single click and opens combo box popups immediately, and enable it for the BCPROP keywords table.
912 lines
37 KiB
C++
912 lines
37 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2025 Equinor 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 "RicExportSectorModelUi.h"
|
|
|
|
#include "RiaApplication.h"
|
|
#include "RiaLogging.h"
|
|
|
|
#include "RicRefinementSettings.h"
|
|
|
|
#include "RigActiveCellInfo.h"
|
|
#include "RigEclipseCaseData.h"
|
|
#include "RigEclipseResultTools.h"
|
|
#include "RigMainGrid.h"
|
|
#include "RigModelPaddingSettings.h"
|
|
|
|
#include "Jobs/RimKeywordBcprop.h"
|
|
#include "RimEclipseCase.h"
|
|
#include "RimEclipseView.h"
|
|
#include "RimRefinementRegion.h"
|
|
#include "RimRefinementRegionCollection.h"
|
|
#include "RimTools.h"
|
|
#include "Tools/RimEclipseViewTools.h"
|
|
|
|
#include "RigNoRefinement.h"
|
|
|
|
#include "cafPdmUiCheckBoxEditor.h"
|
|
#include "cafPdmUiFilePathEditor.h"
|
|
#include "cafPdmUiGroup.h"
|
|
#include "cafPdmUiLineEditor.h"
|
|
#include "cafPdmUiListEditor.h"
|
|
#include "cafPdmUiRadioButtonEditor.h"
|
|
#include "cafPdmUiTableViewEditor.h"
|
|
#include "cafPdmUiTreeSelectionEditor.h"
|
|
|
|
#include <QFileInfo>
|
|
|
|
#include <utility>
|
|
|
|
CAF_PDM_SOURCE_INIT( RicExportSectorModelUi, "RicExportSectorModelUi" );
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RicExportSectorModelUi::RicExportSectorModelUi()
|
|
: m_visibleMin( caf::VecIjk0::ZERO )
|
|
, m_visibleMax( caf::VecIjk0::ZERO )
|
|
, m_totalCells( 0 )
|
|
{
|
|
CAF_PDM_InitObject( "Export Sector Model for Simulation Input" );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_exportFolder, "ExportFolder", "Export Folder" );
|
|
CAF_PDM_InitFieldNoDefault( &m_exportDeckName, "ExportDeckName", "Sector Model Name" );
|
|
CAF_PDM_InitFieldNoDefault( &m_inputDeckName, "InputDeckName", "Source DATA File" );
|
|
m_inputDeckName.xmlCapability()->disableIO();
|
|
|
|
CAF_PDM_InitField( &m_porvMultiplier, "PorvMultiplier", 1.0e6, "PORV Multiplier" );
|
|
CAF_PDM_InitFieldNoDefault( &m_boundaryCondition, "BoundaryCondition", "Boundary Condition Type:" );
|
|
m_boundaryCondition.uiCapability()->setUiEditorTypeName( caf::PdmUiRadioButtonEditor::uiEditorTypeName() );
|
|
CAF_PDM_InitFieldNoDefault( &m_gridBoxSelection, "GridBoxSelection", "Cells to Export:" );
|
|
m_gridBoxSelection.uiCapability()->setUiEditorTypeName( caf::PdmUiRadioButtonEditor::uiEditorTypeName() );
|
|
|
|
CAF_PDM_InitField( &m_visibleWellsPadding, "VisibleWellsPadding", 2, "Well Padding", "", "Number of cells to add around visible wells", "" );
|
|
m_visibleWellsPadding.setRange( 0, 100 );
|
|
|
|
CAF_PDM_InitField( &m_minI, "MinI", 1, "Min I, J, K" );
|
|
CAF_PDM_InitField( &m_minJ, "MinJ", 1, "" );
|
|
m_minJ.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::LabelPosition::HIDDEN );
|
|
CAF_PDM_InitField( &m_minK, "MinK", 1, "" );
|
|
m_minK.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::LabelPosition::HIDDEN );
|
|
m_minI.setMinValue( 1 );
|
|
m_minJ.setMinValue( 1 );
|
|
m_minK.setMinValue( 1 );
|
|
|
|
CAF_PDM_InitField( &m_maxI, "MaxI", 1, "Max I, J, K" );
|
|
CAF_PDM_InitField( &m_maxJ, "MaxJ", 1, "" );
|
|
m_maxJ.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::LabelPosition::HIDDEN );
|
|
CAF_PDM_InitField( &m_maxK, "MaxK", 1, "" );
|
|
m_maxK.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::LabelPosition::HIDDEN );
|
|
|
|
m_maxI.setMinValue( 1 );
|
|
m_maxJ.setMinValue( 1 );
|
|
m_maxK.setMinValue( 1 );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_refinementSettings, "RefinementSettings", "" );
|
|
m_refinementSettings = new RicRefinementSettings();
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_selectedRegions, "SelectedRefinementRegions", "Refinement Regions" );
|
|
m_selectedRegions.uiCapability()->setUiEditorTypeName( caf::PdmUiTreeSelectionEditor::uiEditorTypeName() );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_bcpropKeywords, "BcpropKeywords", "BCPROP Keywords" );
|
|
m_bcpropKeywords.uiCapability()->setUiEditorTypeName( caf::PdmUiTableViewEditor::uiEditorTypeName() );
|
|
m_bcpropKeywords.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::LabelPosition::HIDDEN );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_keywordsToRemove, "KeywordsToRemove", "Keywords to Remove from Output" );
|
|
m_keywordsToRemove.uiCapability()->setUiEditorTypeName( caf::PdmUiListEditor::uiEditorTypeName() );
|
|
setDefaultKeywordsToRemove();
|
|
|
|
// Model padding fields
|
|
CAF_PDM_InitField( &m_enablePadding, "EnablePadding", false, "Enable Model Padding" );
|
|
caf::PdmUiNativeCheckBoxEditor::configureFieldForEditor( &m_enablePadding );
|
|
|
|
CAF_PDM_InitField( &m_paddingNzUpper, "PaddingNzUpper", 0, "Number of Z Layers" );
|
|
m_paddingNzUpper.setRange( 0, 100 );
|
|
|
|
CAF_PDM_InitField( &m_paddingTopUpper, "PaddingTopUpper", 0.0, "Top Depth" );
|
|
|
|
CAF_PDM_InitField( &m_paddingUpperPorosity, "PaddingUpperPorosity", 0.0, "Porosity" );
|
|
m_paddingUpperPorosity.setRange( 0.0, 1.0 );
|
|
|
|
CAF_PDM_InitField( &m_paddingUpperEquilnum, "PaddingUpperEquilnum", 1, "EQUILNUM" );
|
|
m_paddingUpperEquilnum.setMinValue( 1 );
|
|
|
|
CAF_PDM_InitField( &m_paddingNzLower, "PaddingNzLower", 0, "Number of Z Layers" );
|
|
m_paddingNzLower.setRange( 0, 100 );
|
|
|
|
CAF_PDM_InitField( &m_paddingBottomLower, "PaddingBottomLower", 0.0, "Bottom Depth" );
|
|
|
|
CAF_PDM_InitField( &m_paddingMinThickness, "PaddingMinThickness", 0.1, "Minimum Layer Thickness" );
|
|
m_paddingMinThickness.setMinValue( 0.001 );
|
|
|
|
CAF_PDM_InitField( &m_paddingFillGaps, "PaddingFillGaps", false, "Fill Gaps in Z Direction" );
|
|
caf::PdmUiNativeCheckBoxEditor::configureFieldForEditor( &m_paddingFillGaps );
|
|
|
|
CAF_PDM_InitField( &m_paddingMonotonicZcorn, "PaddingMonotonicZcorn", false, "Enforce Monotonic Z-Corners" );
|
|
caf::PdmUiNativeCheckBoxEditor::configureFieldForEditor( &m_paddingMonotonicZcorn );
|
|
|
|
CAF_PDM_InitField( &m_paddingVerticalPillars, "PaddingVerticalPillars", false, "Make Pillars Vertical" );
|
|
caf::PdmUiNativeCheckBoxEditor::configureFieldForEditor( &m_paddingVerticalPillars );
|
|
|
|
CAF_PDM_InitField( &m_createSimulationJob, "CreateSimulationJob", false, "Create New Simulation Job" );
|
|
caf::PdmUiNativeCheckBoxEditor::configureFieldForEditor( &m_createSimulationJob );
|
|
CAF_PDM_InitFieldNoDefault( &m_simulationJobFolder, "SimulationJobFolder", "Working Folder" );
|
|
CAF_PDM_InitFieldNoDefault( &m_simulationJobName, "SimulationJobName", "Job Name" );
|
|
CAF_PDM_InitField( &m_startSimulationJobAfterExport,
|
|
"StartSimulationJobAfterExport",
|
|
false,
|
|
"Start Simulation Job After Export",
|
|
"",
|
|
"Automatically start all jobs using the exported sector model file as input." );
|
|
caf::PdmUiNativeCheckBoxEditor::configureFieldForEditor( &m_startSimulationJobAfterExport );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_eclipseCase, "EclipseCase", "Source Eclipse Case" );
|
|
m_eclipseCase.uiCapability()->setUiReadOnly( true );
|
|
CAF_PDM_InitFieldNoDefault( &m_eclipseView, "EclipseView", "Source View" );
|
|
m_eclipseView.uiCapability()->setUiHidden( true );
|
|
|
|
m_exportFolder = defaultFolder();
|
|
|
|
m_pageNames << "General Settings";
|
|
m_pageSubtitles << "Select the name (no extension) and the output folder of the new sector model.";
|
|
|
|
m_pageNames << "Sector Model Definition";
|
|
m_pageSubtitles << "Select grid box to export as a new sector model.";
|
|
|
|
m_pageNames << "Refinement";
|
|
m_pageSubtitles << "Set up optional sector model grid refinement.";
|
|
|
|
m_pageNames << "Boundary Conditions";
|
|
m_pageSubtitles << "Set up the boundary conditions of the new sector model.";
|
|
|
|
m_pageNames << "Keyword Adjustments";
|
|
m_pageSubtitles << "Set up special handling of certain keywords.";
|
|
|
|
m_pageNames << "Model Padding";
|
|
m_pageSubtitles << "Configure optional Z-direction padding for the sector model grid.";
|
|
|
|
m_pageNames << "Simulation Job Settings";
|
|
m_pageSubtitles << "Optionally create and/or run a simulation job using the exported sector model.";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RicExportSectorModelUi::~RicExportSectorModelUi()
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicExportSectorModelUi::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
|
|
{
|
|
// must be kept in sync with the page names defined in the constructor
|
|
CAF_ASSERT( m_pageNames.size() == (size_t)WizardPageEnum::TotalPages );
|
|
|
|
if ( uiConfigName == m_pageNames[WizardPageEnum::ExportSettings] )
|
|
{
|
|
uiOrdering.add( &m_exportDeckName );
|
|
uiOrdering.add( &m_exportFolder );
|
|
|
|
auto infoGrp = uiOrdering.addNewGroup( "Source Information" );
|
|
infoGrp->addNewLabel( QString( "Source Folder: " ) + m_eclipseCase->locationOnDisc() );
|
|
infoGrp->addNewLabel( QString( "Source Case Name: " ) + m_eclipseCase->caseUserDescription() );
|
|
infoGrp->add( &m_inputDeckName );
|
|
}
|
|
else if ( uiConfigName == m_pageNames[WizardPageEnum::GridBoxSelection] )
|
|
{
|
|
uiOrdering.add( &m_gridBoxSelection, { .newRow = true, .totalColumnSpan = 4, .leftLabelColumnSpan = 1 } );
|
|
|
|
uiOrdering.addNewLabel( "" );
|
|
|
|
uiOrdering.add( &m_minI, { .newRow = true, .totalColumnSpan = 2, .leftLabelColumnSpan = 1 } );
|
|
uiOrdering.appendToRow( &m_minJ );
|
|
uiOrdering.appendToRow( &m_minK );
|
|
|
|
uiOrdering.add( &m_maxI, { .newRow = true, .totalColumnSpan = 2, .leftLabelColumnSpan = 1 } );
|
|
uiOrdering.appendToRow( &m_maxJ );
|
|
uiOrdering.appendToRow( &m_maxK );
|
|
|
|
if ( m_gridBoxSelection() == RiaModelExportDefines::VISIBLE_WELLS_BOX )
|
|
{
|
|
uiOrdering.add( &m_visibleWellsPadding, { .newRow = true, .totalColumnSpan = 2, .leftLabelColumnSpan = 1 } );
|
|
uiOrdering.addNewLabel( "(cells)", { .newRow = false } );
|
|
}
|
|
|
|
const bool boxReadOnly = ( m_gridBoxSelection() != RiaModelExportDefines::MANUAL_SELECTION );
|
|
m_minI.uiCapability()->setUiReadOnly( boxReadOnly );
|
|
m_minJ.uiCapability()->setUiReadOnly( boxReadOnly );
|
|
m_minK.uiCapability()->setUiReadOnly( boxReadOnly );
|
|
m_maxI.uiCapability()->setUiReadOnly( boxReadOnly );
|
|
m_maxJ.uiCapability()->setUiReadOnly( boxReadOnly );
|
|
m_maxK.uiCapability()->setUiReadOnly( boxReadOnly );
|
|
|
|
uiOrdering.addNewLabel( "" );
|
|
uiOrdering.addNewLabel( QString( "Total cells to export: %1" ).arg( m_totalCells ) );
|
|
}
|
|
else if ( uiConfigName == m_pageNames[WizardPageEnum::GridRefinement] )
|
|
{
|
|
uiOrdering.addNewLabel( "Refinement regions are managed in the project tree under the 3D view." );
|
|
uiOrdering.addNewLabel( "Right-click the view and choose 'New Refinement Region' to create one." );
|
|
uiOrdering.addNewLabel( "" );
|
|
|
|
auto* group = uiOrdering.addNewGroup( "Regions to Include in Export" );
|
|
group->add( &m_selectedRegions );
|
|
}
|
|
else if ( uiConfigName == m_pageNames[WizardPageEnum::BoundaryConditions] )
|
|
{
|
|
uiOrdering.add( &m_boundaryCondition );
|
|
uiOrdering.addNewLabel( "", { .newRow = false } ); // needed to get proper visual layout in BCCON/BCPROP case
|
|
|
|
if ( m_boundaryCondition() == RiaModelExportDefines::OPERNUM_OPERATER )
|
|
{
|
|
uiOrdering.add( &m_porvMultiplier );
|
|
uiOrdering.addNewLabel( "", { .newRow = false } ); // needed to get proper visual layout
|
|
}
|
|
else if ( m_boundaryCondition() == RiaModelExportDefines::BCCON_BCPROP )
|
|
{
|
|
uiOrdering.add( &m_bcpropKeywords );
|
|
}
|
|
}
|
|
else if ( uiConfigName == m_pageNames[WizardPageEnum::KeywordAdjustments] )
|
|
{
|
|
uiOrdering.add( &m_keywordsToRemove );
|
|
uiOrdering.addNewButton( "Reset to Default",
|
|
[this]()
|
|
{
|
|
setDefaultKeywordsToRemove();
|
|
updateConnectedEditors();
|
|
} );
|
|
}
|
|
else if ( uiConfigName == m_pageNames[WizardPageEnum::ModelPadding] )
|
|
{
|
|
uiOrdering.add( &m_enablePadding );
|
|
uiOrdering.addNewLabel( "" );
|
|
|
|
if ( m_enablePadding() )
|
|
{
|
|
auto upperGrp = uiOrdering.addNewGroup( "Upper Padding" );
|
|
upperGrp->add( &m_paddingNzUpper );
|
|
upperGrp->add( &m_paddingTopUpper );
|
|
upperGrp->add( &m_paddingUpperPorosity );
|
|
upperGrp->add( &m_paddingUpperEquilnum );
|
|
|
|
auto lowerGrp = uiOrdering.addNewGroup( "Lower Padding" );
|
|
lowerGrp->add( &m_paddingNzLower );
|
|
lowerGrp->add( &m_paddingBottomLower );
|
|
|
|
auto optionsGrp = uiOrdering.addNewGroup( "Grid Options" );
|
|
optionsGrp->add( &m_paddingMinThickness );
|
|
optionsGrp->add( &m_paddingFillGaps );
|
|
optionsGrp->add( &m_paddingMonotonicZcorn );
|
|
optionsGrp->add( &m_paddingVerticalPillars );
|
|
}
|
|
}
|
|
else if ( uiConfigName == m_pageNames[WizardPageEnum::SimulationJob] )
|
|
{
|
|
auto simGrp = uiOrdering.addNewGroup( "OPM Flow Simulation" );
|
|
simGrp->add( &m_createSimulationJob );
|
|
if ( m_createSimulationJob() )
|
|
{
|
|
if ( m_simulationJobName().isEmpty() ) m_simulationJobName = m_exportDeckName().trimmed();
|
|
simGrp->add( &m_simulationJobName );
|
|
simGrp->add( &m_simulationJobFolder );
|
|
}
|
|
uiOrdering.add( &m_startSimulationJobAfterExport );
|
|
}
|
|
|
|
uiOrdering.skipRemainingFields();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const QStringList& RicExportSectorModelUi::pageNames() const
|
|
{
|
|
return m_pageNames;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const QStringList& RicExportSectorModelUi::pageSubTitles() const
|
|
{
|
|
return m_pageSubtitles;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicExportSectorModelUi::setEclipseView( RimEclipseView* view )
|
|
{
|
|
m_eclipseView = view;
|
|
|
|
if ( view->eclipseCase() != m_eclipseCase() ) m_exportDeckName = "";
|
|
|
|
m_eclipseCase = view->eclipseCase();
|
|
|
|
cvf::UByteArray cellVisibility;
|
|
view->calculateCurrentTotalCellVisibility( &cellVisibility, view->currentTimeStep() );
|
|
|
|
const auto& [min, max] = RimEclipseViewTools::getVisibleCellRange( view, cellVisibility );
|
|
m_visibleMax = max;
|
|
m_visibleMin = min;
|
|
|
|
applyBoundaryDefaults();
|
|
|
|
// Initialize BCPROP keywords based on max BCCON value in the grid
|
|
int maxBccon = RigEclipseResultTools::findMaxBcconValue( m_eclipseCase() );
|
|
|
|
// Clear existing keywords
|
|
m_bcpropKeywords.deleteChildren();
|
|
|
|
// Add appropriate number of BCPROP keywords (max BCCON value or default to 6 for the 6 faces)
|
|
int numKeywords = ( maxBccon > 0 ) ? maxBccon : 6;
|
|
for ( int i = 0; i < numKeywords; ++i )
|
|
{
|
|
auto* keyword = new RimKeywordBcprop();
|
|
keyword->setIndex( i + 1 ); // BCCON values start from 1, not 0
|
|
m_bcpropKeywords.push_back( keyword );
|
|
}
|
|
|
|
if ( ( m_eclipseCase != nullptr ) && m_exportDeckName().isEmpty() )
|
|
m_exportDeckName = m_eclipseCase->caseUserDescription().toUpper() + +"_SECTOR";
|
|
|
|
m_createSimulationJob = false;
|
|
|
|
if ( m_exportFolder().path().isEmpty() ) m_exportFolder = defaultFolder();
|
|
|
|
// Get default input deck file name from eclipse case
|
|
QFileInfo fi( view->eclipseCase()->gridFileName() );
|
|
m_inputDeckName = fi.absolutePath() + "/" + fi.completeBaseName() + ".DATA";
|
|
|
|
// Preselect any existing refinement regions so the user doesn't have to tick them manually.
|
|
m_selectedRegions.clearWithoutDelete();
|
|
if ( auto* collection = view->refinementRegionCollection() )
|
|
{
|
|
for ( auto* region : collection->regions() )
|
|
{
|
|
if ( region != nullptr ) m_selectedRegions.push_back( region );
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicExportSectorModelUi::defineEditorAttribute( const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute )
|
|
{
|
|
if ( field == &m_bcpropKeywords )
|
|
{
|
|
auto* tvAttr = dynamic_cast<caf::PdmUiTableViewEditorAttribute*>( attribute );
|
|
if ( tvAttr )
|
|
{
|
|
tvAttr->resizePolicy = caf::PdmUiTableViewEditorAttribute::RESIZE_TO_FILL_CONTAINER;
|
|
tvAttr->alwaysEnforceResizePolicy = true;
|
|
tvAttr->editOnSingleClick = true;
|
|
}
|
|
}
|
|
else if ( ( field == &m_exportFolder ) || ( field == &m_simulationJobFolder ) )
|
|
{
|
|
caf::PdmUiFilePathEditorAttribute* myAttr = dynamic_cast<caf::PdmUiFilePathEditorAttribute*>( attribute );
|
|
if ( myAttr )
|
|
{
|
|
myAttr->m_selectDirectory = true;
|
|
}
|
|
}
|
|
else if ( field == &m_keywordsToRemove )
|
|
{
|
|
auto attrib = dynamic_cast<caf::PdmUiListEditorAttribute*>( attribute );
|
|
if ( attrib )
|
|
{
|
|
attrib->heightHint = 200;
|
|
}
|
|
}
|
|
else if ( field == &m_selectedRegions )
|
|
{
|
|
auto attrib = dynamic_cast<caf::PdmUiTreeSelectionEditorAttribute*>( attribute );
|
|
if ( attrib )
|
|
{
|
|
attrib->heightHint = 100;
|
|
}
|
|
}
|
|
else if ( field == &m_inputDeckName )
|
|
{
|
|
caf::PdmUiFilePathEditorAttribute* myAttr = dynamic_cast<caf::PdmUiFilePathEditorAttribute*>( attribute );
|
|
if ( myAttr )
|
|
{
|
|
myAttr->m_fileSelectionFilter = "Eclipse DATA files (*.DATA);;All files (*.*)";
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicExportSectorModelUi::setDefaultKeywordsToRemove()
|
|
{
|
|
m_keywordsToRemove.setValue( { "ACTION", "ACTIONX", "ACTIONW", "BOX", "UDQ" } );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
caf::VecIjk0 RicExportSectorModelUi::min() const
|
|
{
|
|
return caf::VecIjk0( m_minI() - 1, m_minJ() - 1, m_minK() - 1 );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
caf::VecIjk0 RicExportSectorModelUi::max() const
|
|
{
|
|
return caf::VecIjk0( m_maxI() - 1, m_maxJ() - 1, m_maxK() - 1 );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicExportSectorModelUi::setMin( const caf::VecIjk0& min )
|
|
{
|
|
m_minI = static_cast<int>( min.x() ) + 1;
|
|
m_minJ = static_cast<int>( min.y() ) + 1;
|
|
m_minK = static_cast<int>( min.z() ) + 1;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicExportSectorModelUi::setMax( const caf::VecIjk0& max )
|
|
{
|
|
m_maxI = static_cast<int>( max.x() ) + 1;
|
|
m_maxJ = static_cast<int>( max.y() ) + 1;
|
|
m_maxK = static_cast<int>( max.z() ) + 1;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RicRefinementSettings* RicExportSectorModelUi::refinementSettings() const
|
|
{
|
|
return m_refinementSettings();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::unique_ptr<RigRefinement> RicExportSectorModelUi::effectiveRefinement() const
|
|
{
|
|
std::vector<RimRefinementRegion*> regions;
|
|
for ( const auto& r : m_selectedRegions )
|
|
{
|
|
if ( r ) regions.push_back( r );
|
|
}
|
|
|
|
auto combined = RimRefinementRegionCollection::combineRefinements( min(), max(), regions );
|
|
if ( combined.has_value() )
|
|
{
|
|
return std::move( *combined );
|
|
}
|
|
|
|
// Error: fall back to identity. The validate() step should have caught this already.
|
|
cvf::Vec3st sectorSize( max().x() - min().x() + 1, max().y() - min().y() + 1, max().z() - min().z() + 1 );
|
|
return std::make_unique<RigNoRefinement>( sectorSize );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RicExportSectorModelUi::hasNonUniformRefinement() const
|
|
{
|
|
// With the new region-based model, any selected region producing non-identity refinement is
|
|
// treated as non-uniform (even if each region is internally uniform) because the combined
|
|
// RigRefinement is built as RigNonUniformRefinement.
|
|
return !m_selectedRegions.empty();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<QString> RicExportSectorModelUi::keywordsToRemove() const
|
|
{
|
|
return m_keywordsToRemove.value();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RimKeywordBcprop*> RicExportSectorModelUi::bcpropKeywords() const
|
|
{
|
|
std::vector<RimKeywordBcprop*> keywords;
|
|
for ( auto& kw : m_bcpropKeywords )
|
|
{
|
|
keywords.push_back( kw );
|
|
}
|
|
return keywords;
|
|
}
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiaModelExportDefines::BoundaryCondition RicExportSectorModelUi::boundaryCondition() const
|
|
{
|
|
return m_boundaryCondition();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RicExportSectorModelUi::porvMultiplier() const
|
|
{
|
|
return m_porvMultiplier();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RicExportSectorModelUi::exportDeckFilename() const
|
|
{
|
|
QString fullpath = m_exportFolder().path() + "/" + m_exportDeckName + ".DATA";
|
|
|
|
RiaApplication::instance()->setLastUsedDialogDirectory( "EXPORT_INPUT_GRID", fullpath );
|
|
|
|
return fullpath;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RicExportSectorModelUi::inputDeckFilename() const
|
|
{
|
|
return m_inputDeckName().path();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiaModelExportDefines::GridBoxSelection RicExportSectorModelUi::gridBoxSelection() const
|
|
{
|
|
return m_gridBoxSelection();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
int RicExportSectorModelUi::wellPadding() const
|
|
{
|
|
return m_visibleWellsPadding();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QList<caf::PdmOptionItemInfo> RicExportSectorModelUi::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions )
|
|
{
|
|
QList<caf::PdmOptionItemInfo> options;
|
|
|
|
if ( fieldNeedingOptions == &m_selectedRegions )
|
|
{
|
|
if ( m_eclipseView() )
|
|
{
|
|
if ( auto* collection = m_eclipseView()->refinementRegionCollection() )
|
|
{
|
|
for ( auto* region : collection->regions() )
|
|
{
|
|
if ( !region ) continue;
|
|
options.push_back( caf::PdmOptionItemInfo( region->regionName(), region ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicExportSectorModelUi::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
|
|
{
|
|
if ( changedField == &m_gridBoxSelection )
|
|
{
|
|
applyBoundaryDefaults();
|
|
updateConnectedEditors();
|
|
}
|
|
if ( changedField == &m_visibleWellsPadding || changedField == &m_minI || changedField == &m_maxI || changedField == &m_minJ ||
|
|
changedField == &m_maxJ || changedField == &m_minK || changedField == &m_maxK )
|
|
{
|
|
applyBoundaryDefaults();
|
|
}
|
|
else if ( ( changedField == &m_boundaryCondition ) || ( changedField == &m_enablePadding ) )
|
|
{
|
|
updateConnectedEditors();
|
|
}
|
|
else if ( changedField == &m_exportFolder )
|
|
{
|
|
if ( m_simulationJobFolder().path().isEmpty() )
|
|
{
|
|
m_simulationJobFolder = m_exportFolder().path() + "/job";
|
|
}
|
|
updateConnectedEditors();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicExportSectorModelUi::applyBoundaryDefaults()
|
|
{
|
|
auto caseData = m_eclipseCase->eclipseCaseData();
|
|
if ( !caseData ) return;
|
|
|
|
if ( m_gridBoxSelection == RiaModelExportDefines::ACTIVE_CELLS_BOX )
|
|
{
|
|
const auto& bbox = caseData->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL )->ijkBoundingBox();
|
|
setMin( bbox.min() );
|
|
setMax( bbox.max() );
|
|
}
|
|
else if ( m_gridBoxSelection == RiaModelExportDefines::VISIBLE_CELLS_BOX )
|
|
{
|
|
setMin( m_visibleMin );
|
|
setMax( m_visibleMax );
|
|
}
|
|
else if ( m_gridBoxSelection == RiaModelExportDefines::VISIBLE_WELLS_BOX )
|
|
{
|
|
auto [minWellCells, maxWellCells] = RimEclipseViewTools::computeVisibleWellCells( m_eclipseView, caseData, m_visibleWellsPadding() );
|
|
setMin( minWellCells );
|
|
setMax( maxWellCells );
|
|
}
|
|
else if ( m_gridBoxSelection == RiaModelExportDefines::FULL_GRID_BOX )
|
|
{
|
|
const RigMainGrid* mainGrid = caseData->mainGrid();
|
|
setMin( caf::VecIjk0::ZERO );
|
|
cvf::Vec3st maxCounts = mainGrid->cellCounts() - cvf::Vec3st( 1, 1, 1 );
|
|
setMax( caf::VecIjk0( maxCounts.x(), maxCounts.y(), maxCounts.z() ) );
|
|
}
|
|
else
|
|
{
|
|
const RigMainGrid* mainGrid = caseData->mainGrid();
|
|
|
|
if ( m_maxI() > (int)mainGrid->cellCountI() )
|
|
{
|
|
m_maxI = (int)mainGrid->cellCountI();
|
|
}
|
|
if ( m_maxJ() > (int)mainGrid->cellCountJ() )
|
|
{
|
|
m_maxJ = (int)mainGrid->cellCountJ();
|
|
}
|
|
if ( m_maxK() > (int)mainGrid->cellCountK() )
|
|
{
|
|
m_maxK = (int)mainGrid->cellCountK();
|
|
}
|
|
}
|
|
|
|
m_totalCells = std::max( 0, ( ( m_maxI() - m_minI() + 1 ) * ( m_maxJ() - m_minJ() + 1 ) * ( m_maxK() - m_minK() + 1 ) ) );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RicExportSectorModelUi::defaultFolder()
|
|
{
|
|
QString projectDirectory = RiaApplication::instance()->currentProjectPath();
|
|
QString fallbackDirectory = projectDirectory;
|
|
if ( fallbackDirectory.isEmpty() )
|
|
{
|
|
QString generalFallback = RiaApplication::instance()->lastUsedDialogDirectory( "GENERAL_DATA" );
|
|
fallbackDirectory = RiaApplication::instance()->lastUsedDialogDirectoryWithFallback( "BINARY_GRID", generalFallback );
|
|
}
|
|
return RiaApplication::instance()->lastUsedDialogDirectoryWithFallback( "EXPORT_INPUT_GRID", fallbackDirectory );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RicExportSectorModelUi::shouldCreateSimulationJob() const
|
|
{
|
|
return m_createSimulationJob();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RicExportSectorModelUi::startSimulationJobAfterExport() const
|
|
{
|
|
return m_startSimulationJobAfterExport();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RicExportSectorModelUi::newSimulationJobFolder() const
|
|
{
|
|
return m_simulationJobFolder().path();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RicExportSectorModelUi::newSimulationJobName() const
|
|
{
|
|
return m_simulationJobName();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RigModelPaddingSettings RicExportSectorModelUi::paddingSettings() const
|
|
{
|
|
RigModelPaddingSettings settings;
|
|
settings.setEnabled( m_enablePadding() );
|
|
settings.setNzUpper( m_paddingNzUpper() );
|
|
settings.setTopUpper( m_paddingTopUpper() );
|
|
settings.setUpperPorosity( m_paddingUpperPorosity() );
|
|
settings.setUpperEquilnum( m_paddingUpperEquilnum() );
|
|
settings.setNzLower( m_paddingNzLower() );
|
|
settings.setBottomLower( m_paddingBottomLower() );
|
|
settings.setMinLayerThickness( m_paddingMinThickness() );
|
|
settings.setFillGaps( m_paddingFillGaps() );
|
|
settings.setMonotonicZcorn( m_paddingMonotonicZcorn() );
|
|
settings.setVerticalPillars( m_paddingVerticalPillars() );
|
|
return settings;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::map<QString, QString> RicExportSectorModelUi::validate( const QString& configName ) const
|
|
{
|
|
std::map<QString, QString> fieldErrors;
|
|
|
|
if ( configName == m_pageNames[WizardPageEnum::ExportSettings] )
|
|
{
|
|
if ( m_exportDeckName().trimmed().isEmpty() )
|
|
{
|
|
fieldErrors[m_exportDeckName.keyword()] = "Output sector model name cannot be empty.";
|
|
}
|
|
if ( m_exportFolder().path().trimmed().isEmpty() )
|
|
{
|
|
fieldErrors[m_exportFolder.keyword()] = "Export folder cannot be empty.";
|
|
}
|
|
if ( m_exportFolder().path() == m_eclipseCase->locationOnDisc() )
|
|
{
|
|
fieldErrors[m_exportFolder.keyword()] = "Export folder cannot be the same as the source case folder.";
|
|
}
|
|
}
|
|
else if ( configName == m_pageNames[WizardPageEnum::GridBoxSelection] )
|
|
{
|
|
if ( ( m_eclipseCase == nullptr ) || ( m_eclipseCase->eclipseCaseData() == nullptr ) ||
|
|
( m_eclipseCase->eclipseCaseData()->mainGrid() == nullptr ) )
|
|
return {};
|
|
|
|
const RigMainGrid* mainGrid = m_eclipseCase->eclipseCaseData()->mainGrid();
|
|
const cvf::Vec3st gridDimensions = mainGrid->cellCounts();
|
|
|
|
for ( auto& field : { &m_minI, &m_minJ, &m_minK, &m_maxI, &m_maxJ, &m_maxK } )
|
|
{
|
|
auto errStr = field->validate();
|
|
if ( !errStr.isEmpty() )
|
|
{
|
|
fieldErrors[field->keyword()] = errStr;
|
|
}
|
|
}
|
|
|
|
if ( m_gridBoxSelection() == RiaModelExportDefines::MANUAL_SELECTION )
|
|
{
|
|
if ( m_minI() > m_maxI() )
|
|
{
|
|
fieldErrors[m_minI.keyword()] = "Min I cannot be larger than Max I.";
|
|
}
|
|
if ( m_minJ() > m_maxJ() )
|
|
{
|
|
fieldErrors[m_minJ.keyword()] = "Min J cannot be larger than Max J.";
|
|
}
|
|
if ( m_minK() > m_maxK() )
|
|
{
|
|
fieldErrors[m_minK.keyword()] = "Min K cannot be larger than Max K.";
|
|
}
|
|
if ( m_maxI() > (int)gridDimensions.x() )
|
|
{
|
|
fieldErrors[m_maxI.keyword()] = QString( "Max I cannot be larger than %1." ).arg( gridDimensions.x() );
|
|
}
|
|
if ( m_maxJ() > (int)gridDimensions.y() )
|
|
{
|
|
fieldErrors[m_maxJ.keyword()] = QString( "Max J cannot be larger than %1." ).arg( gridDimensions.y() );
|
|
}
|
|
if ( m_maxK() > (int)gridDimensions.z() )
|
|
{
|
|
fieldErrors[m_maxK.keyword()] = QString( "Max K cannot be larger than %1." ).arg( gridDimensions.z() );
|
|
}
|
|
}
|
|
else if ( m_gridBoxSelection() == RiaModelExportDefines::VISIBLE_WELLS_BOX )
|
|
{
|
|
auto errStr = m_visibleWellsPadding.validate();
|
|
if ( !errStr.isEmpty() )
|
|
{
|
|
fieldErrors[m_visibleWellsPadding.keyword()] = errStr;
|
|
}
|
|
}
|
|
}
|
|
else if ( configName == m_pageNames[WizardPageEnum::GridRefinement] )
|
|
{
|
|
std::vector<RimRefinementRegion*> regions;
|
|
for ( const auto& r : m_selectedRegions )
|
|
{
|
|
if ( r ) regions.push_back( r );
|
|
}
|
|
|
|
auto combined = RimRefinementRegionCollection::combineRefinements( min(), max(), regions );
|
|
if ( !combined.has_value() )
|
|
{
|
|
fieldErrors[m_selectedRegions.keyword()] = combined.error();
|
|
}
|
|
}
|
|
else if ( configName == m_pageNames[WizardPageEnum::BoundaryConditions] )
|
|
{
|
|
// no validation needed
|
|
}
|
|
else if ( configName == m_pageNames[WizardPageEnum::KeywordAdjustments] )
|
|
{
|
|
for ( auto& kw : m_keywordsToRemove() )
|
|
{
|
|
if ( kw.contains( ' ' ) )
|
|
{
|
|
fieldErrors[m_keywordsToRemove.keyword()] = "Keywords to remove cannot contain spaces: " + kw;
|
|
}
|
|
}
|
|
}
|
|
else if ( configName == m_pageNames[WizardPageEnum::ModelPadding] )
|
|
{
|
|
if ( m_enablePadding() )
|
|
{
|
|
auto settings = paddingSettings();
|
|
auto errMessage = settings.validate();
|
|
if ( !errMessage.isEmpty() )
|
|
{
|
|
fieldErrors[m_enablePadding.keyword()] = errMessage;
|
|
}
|
|
}
|
|
}
|
|
else if ( configName == m_pageNames[WizardPageEnum::SimulationJob] )
|
|
{
|
|
if ( m_createSimulationJob() )
|
|
{
|
|
if ( m_simulationJobName().trimmed().isEmpty() )
|
|
{
|
|
fieldErrors[m_simulationJobName.keyword()] = "Simulation job name cannot be empty.";
|
|
}
|
|
if ( m_simulationJobFolder().path().trimmed().isEmpty() )
|
|
{
|
|
fieldErrors[m_simulationJobFolder.keyword()] = "Simulation job working folder cannot be empty.";
|
|
}
|
|
if ( m_simulationJobFolder().path() == m_exportFolder().path() )
|
|
{
|
|
fieldErrors[m_simulationJobFolder.keyword()] = "Simulation job working folder cannot be the same as the export folder.";
|
|
}
|
|
if ( m_simulationJobFolder().path() == m_eclipseCase->locationOnDisc() )
|
|
{
|
|
fieldErrors[m_simulationJobFolder.keyword()] =
|
|
"Simulation job working folder cannot be the same as the source case folder.";
|
|
}
|
|
}
|
|
}
|
|
|
|
return fieldErrors;
|
|
}
|