mirror of
https://github.com/OPM/ResInsight.git
synced 2024-12-29 10:21:54 -06:00
1873 lines
82 KiB
C++
1873 lines
82 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2020- 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 "RimStimPlanModel.h"
|
|
|
|
#include "RiaApplication.h"
|
|
#include "RiaCompletionTypeCalculationScheduler.h"
|
|
#include "RiaFractureDefines.h"
|
|
#include "RiaLogging.h"
|
|
#include "RiaStimPlanModelDefines.h"
|
|
|
|
#include "RigEclipseCaseData.h"
|
|
#include "RigFault.h"
|
|
#include "RigMainGrid.h"
|
|
#include "RigStimPlanModelTools.h"
|
|
#include "Well/RigWellPath.h"
|
|
|
|
#include "Rim3dView.h"
|
|
#include "RimAnnotationCollection.h"
|
|
#include "RimAnnotationInViewCollection.h"
|
|
#include "RimColorLegend.h"
|
|
#include "RimColorLegendCollection.h"
|
|
#include "RimColorLegendItem.h"
|
|
#include "RimCompletionTemplateCollection.h"
|
|
#include "RimEclipseCase.h"
|
|
#include "RimEclipseResultDefinition.h"
|
|
#include "RimEclipseView.h"
|
|
#include "RimExtractionConfiguration.h"
|
|
#include "RimFaciesProperties.h"
|
|
#include "RimFaultInView.h"
|
|
#include "RimFaultInViewCollection.h"
|
|
#include "RimModeledWellPath.h"
|
|
#include "RimNonNetLayers.h"
|
|
#include "RimOilField.h"
|
|
#include "RimPerforationCollection.h"
|
|
#include "RimPressureTable.h"
|
|
#include "RimProject.h"
|
|
#include "RimStimPlanModelCalculator.h"
|
|
#include "RimStimPlanModelPlot.h"
|
|
#include "RimStimPlanModelTemplate.h"
|
|
#include "RimStimPlanModelTemplateCollection.h"
|
|
#include "RimTextAnnotation.h"
|
|
#include "RimTools.h"
|
|
#include "RimWellPath.h"
|
|
#include "RimWellPathCollection.h"
|
|
#include "RimWellPathGeometryDef.h"
|
|
#include "RimWellPathTarget.h"
|
|
|
|
#include "Riu3DMainWindowTools.h"
|
|
|
|
#include "cafPdmFieldCvfVec3d.h"
|
|
#include "cafPdmFieldScriptingCapabilityCvfVec3d.h"
|
|
#include "cafPdmObjectScriptingCapability.h"
|
|
#include "cafPdmUiDoubleSliderEditor.h"
|
|
#include "cafPdmUiDoubleValueEditor.h"
|
|
#include "cafPdmUiPushButtonEditor.h"
|
|
#include "cafPdmUiToolButtonEditor.h"
|
|
#include "cafPdmUiTreeOrdering.h"
|
|
|
|
#include "cvfBoundingBox.h"
|
|
#include "cvfMath.h"
|
|
#include "cvfPlane.h"
|
|
|
|
#include <cmath>
|
|
#include <limits>
|
|
#include <memory>
|
|
|
|
CAF_PDM_SOURCE_INIT( RimStimPlanModel, "StimPlanModel" );
|
|
|
|
namespace caf
|
|
{
|
|
template <>
|
|
void caf::AppEnum<RimStimPlanModel::ExtractionType>::setUp()
|
|
{
|
|
addItem( RimStimPlanModel::ExtractionType::TRUE_VERTICAL_THICKNESS, "TVT", "True Vertical Thickness" );
|
|
addItem( RimStimPlanModel::ExtractionType::TRUE_STRATIGRAPHIC_THICKNESS, "TST", "True Stratigraphic Thickness" );
|
|
|
|
setDefault( RimStimPlanModel::ExtractionType::TRUE_VERTICAL_THICKNESS );
|
|
}
|
|
|
|
template <>
|
|
void caf::AppEnum<RimStimPlanModel::FractureOrientation>::setUp()
|
|
{
|
|
addItem( RimStimPlanModel::FractureOrientation::ALONG_WELL_PATH, "Longitudinal", "Along Well Path", QStringList( "ALONG_WELL_PATH" ) );
|
|
addItem( RimStimPlanModel::FractureOrientation::TRANSVERSE_WELL_PATH,
|
|
"Transverse",
|
|
"Transverse (normal) to Well Path",
|
|
QStringList( "TRANSVERSE_WELL_PATH" ) );
|
|
|
|
addItem( RimStimPlanModel::FractureOrientation::AZIMUTH, "Azimuth", "Azimuth", QStringList( "AZIMUTH" ) );
|
|
|
|
setDefault( RimStimPlanModel::FractureOrientation::TRANSVERSE_WELL_PATH );
|
|
}
|
|
|
|
template <>
|
|
void caf::AppEnum<RimStimPlanModel::MissingValueStrategy>::setUp()
|
|
{
|
|
addItem( RimStimPlanModel::MissingValueStrategy::DEFAULT_VALUE, "DEFAULT_VALUE", "Default value" );
|
|
addItem( RimStimPlanModel::MissingValueStrategy::LINEAR_INTERPOLATION, "LINEAR_INTERPOLATION", "Linear interpolation" );
|
|
addItem( RimStimPlanModel::MissingValueStrategy::OTHER_CURVE_PROPERTY, "OTHER_CURVE_PROPERTY", "Other Curve Property" );
|
|
|
|
setDefault( RimStimPlanModel::MissingValueStrategy::DEFAULT_VALUE );
|
|
}
|
|
|
|
template <>
|
|
void caf::AppEnum<RimStimPlanModel::BurdenStrategy>::setUp()
|
|
{
|
|
addItem( RimStimPlanModel::BurdenStrategy::DEFAULT_VALUE, "DEFAULT_VALUE", "Default value" );
|
|
addItem( RimStimPlanModel::BurdenStrategy::GRADIENT, "GRADIENT", "Gradient" );
|
|
|
|
setDefault( RimStimPlanModel::BurdenStrategy::DEFAULT_VALUE );
|
|
}
|
|
}; // namespace caf
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimStimPlanModel::RimStimPlanModel()
|
|
{
|
|
CAF_PDM_InitScriptableObject( "StimPlanModel" );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_stimPlanModelTemplate, "StimPlanModelTemplate", "StimPlan Model Template" );
|
|
CAF_PDM_InitField( &m_editStimPlanModelTemplate, "EditModelTemplate", false, "Edit" );
|
|
m_editStimPlanModelTemplate.uiCapability()->setUiEditorTypeName( caf::PdmUiToolButtonEditor::uiEditorTypeName() );
|
|
m_editStimPlanModelTemplate.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::HIDDEN );
|
|
|
|
CAF_PDM_InitScriptableFieldNoDefault( &m_eclipseCase, "EclipseCase", "Dynamic Case" );
|
|
m_eclipseCase.uiCapability()->setUiReadOnly( true );
|
|
|
|
CAF_PDM_InitScriptableField( &m_timeStep, "TimeStep", 0, "Time Step" );
|
|
m_timeStep.uiCapability()->setUiReadOnly( true );
|
|
|
|
CAF_PDM_InitScriptableFieldNoDefault( &m_initialPressureEclipseCase, "InitialPressureEclipseCase", "Initial Pressure Case" );
|
|
m_initialPressureEclipseCase.uiCapability()->setUiReadOnly( true );
|
|
|
|
CAF_PDM_InitScriptableFieldNoDefault( &m_staticEclipseCase, "StaticEclipseCase", "Static Case" );
|
|
m_staticEclipseCase.uiCapability()->setUiReadOnly( true );
|
|
|
|
CAF_PDM_InitScriptableField( &m_MD, "MeasuredDepth", 0.0, "Measured Depth" );
|
|
m_MD.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleSliderEditor::uiEditorTypeName() );
|
|
|
|
CAF_PDM_InitScriptableField( &m_extractionOffsetTop, "ExtractionOffsetTop", -1.0, "Top Offset" );
|
|
m_extractionOffsetTop.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
|
|
|
|
CAF_PDM_InitScriptableField( &m_extractionOffsetBottom, "ExtractionOffsetBottom", -1.0, "Bottom Offset" );
|
|
m_extractionOffsetBottom.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
|
|
|
|
CAF_PDM_InitScriptableField( &m_extractionDepthTop, "ExtractionDepthTop", -1.0, "Depth" );
|
|
m_extractionDepthTop.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
|
|
m_extractionDepthTop.uiCapability()->setUiReadOnly( true );
|
|
m_extractionDepthTop.capability<caf::PdmAbstractFieldScriptingCapability>()->setIOWriteable( false );
|
|
|
|
CAF_PDM_InitScriptableField( &m_extractionDepthBottom, "ExtractionDepthBottom", -1.0, "Depth" );
|
|
m_extractionDepthBottom.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
|
|
m_extractionDepthBottom.uiCapability()->setUiReadOnly( true );
|
|
m_extractionDepthBottom.capability<caf::PdmAbstractFieldScriptingCapability>()->setIOWriteable( false );
|
|
|
|
CAF_PDM_InitScriptableField( &m_extractionType,
|
|
"ExtractionType",
|
|
caf::AppEnum<ExtractionType>( ExtractionType::TRUE_STRATIGRAPHIC_THICKNESS ),
|
|
"Extraction Type" );
|
|
|
|
CAF_PDM_InitScriptableFieldNoDefault( &m_anchorPosition, "AnchorPosition", "Anchor Position" );
|
|
m_anchorPosition.uiCapability()->setUiReadOnly( true );
|
|
m_anchorPosition.xmlCapability()->disableIO();
|
|
m_anchorPosition.capability<caf::PdmAbstractFieldScriptingCapability>()->setIOWriteable( false );
|
|
|
|
CAF_PDM_InitFieldNoDefault( &m_anchorPositionForUi, "AnchorPositionForUi", "Anchor Position" );
|
|
m_anchorPositionForUi.registerGetMethod( this, &RimStimPlanModel::anchorPositionForUi );
|
|
m_anchorPositionForUi.uiCapability()->setUiReadOnly( true );
|
|
m_anchorPositionForUi.xmlCapability()->disableIO();
|
|
|
|
CAF_PDM_InitScriptableFieldNoDefault( &m_thicknessDirection, "ThicknessDirection", "Thickness Direction" );
|
|
m_thicknessDirection.uiCapability()->setUiReadOnly( true );
|
|
m_thicknessDirection.xmlCapability()->disableIO();
|
|
m_thicknessDirection.capability<caf::PdmAbstractFieldScriptingCapability>()->setIOWriteable( false );
|
|
|
|
CAF_PDM_InitScriptableFieldNoDefault( &m_originalThicknessDirection, "OriginalThicknessDirection", "Original Thickness Direction" );
|
|
m_originalThicknessDirection.uiCapability()->setUiReadOnly( true );
|
|
m_originalThicknessDirection.xmlCapability()->disableIO();
|
|
m_originalThicknessDirection.capability<caf::PdmAbstractFieldScriptingCapability>()->setIOWriteable( false );
|
|
|
|
CAF_PDM_InitScriptableFieldNoDefault( &m_thicknessDirectionWellPath, "ThicknessDirectionWellPath", "Thickness Direction Well Path" );
|
|
m_thicknessDirectionWellPath.capability<caf::PdmAbstractFieldScriptingCapability>()->setIOWriteable( false );
|
|
|
|
CAF_PDM_InitScriptableField( &m_boundingBoxHorizontal, "BoundingBoxHorizontal", 50.0, "Bounding Box Horizontal" );
|
|
CAF_PDM_InitScriptableField( &m_boundingBoxVertical, "BoundingBoxVertical", 100.0, "Bounding Box Vertical" );
|
|
|
|
CAF_PDM_InitScriptableField( &m_useDetailedFluidLoss, "UseDetailedFluidLoss", true, "Use Detailed Fluid Loss" );
|
|
|
|
CAF_PDM_InitScriptableField( &m_relativePermeabilityFactorDefault, "RelativePermeabilityFactor", 0.5, "Relative Permeability Factor" );
|
|
CAF_PDM_InitScriptableField( &m_poroElasticConstantDefault, "PoroElasticConstant", 0.0, "Poro-Elastic Constant" );
|
|
CAF_PDM_InitScriptableField( &m_thermalExpansionCoeffientDefault, "ThermalExpansionCoefficient", 0.0, "Thermal Expansion Coefficient [1/C]" );
|
|
|
|
CAF_PDM_InitScriptableField( &m_perforationLength, "PerforationLength", 10.0, "Perforation Length [m]" );
|
|
CAF_PDM_InitScriptableField( &m_fractureOrientation,
|
|
"FractureOrientation",
|
|
caf::AppEnum<FractureOrientation>( FractureOrientation::ALONG_WELL_PATH ),
|
|
"Fracture Orientation" );
|
|
CAF_PDM_InitScriptableField( &m_azimuthAngle, "AzimuthAngle", 0.0, "Azimuth Angle" );
|
|
|
|
CAF_PDM_InitScriptableField( &m_formationDip, "FormationDip", 0.0, "Formation Dip" );
|
|
m_formationDip.uiCapability()->setUiReadOnly( true );
|
|
m_formationDip.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
|
|
|
|
CAF_PDM_InitScriptableField( &m_autoComputeBarrier, "AutoComputeBarrier", true, "Auto Compute Barrier" );
|
|
CAF_PDM_InitScriptableField( &m_hasBarrier, "Barrier", true, "Barrier" );
|
|
CAF_PDM_InitScriptableField( &m_distanceToBarrier, "DistanceToBarrier", 0.0, "Distance To Barrier [m]" );
|
|
m_distanceToBarrier.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
|
|
m_distanceToBarrier.uiCapability()->setUiReadOnly( true );
|
|
|
|
CAF_PDM_InitScriptableField( &m_barrierDip, "BarrierDip", 0.0, "Barrier Dip" );
|
|
m_barrierDip.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
|
|
m_barrierDip.uiCapability()->setUiReadOnly( true );
|
|
CAF_PDM_InitScriptableField( &m_wellPenetrationLayer, "WellPenetrationLayer", 2, "Well Penetration Layer" );
|
|
|
|
CAF_PDM_InitScriptableField( &m_showOnlyBarrierFault, "ShowOnlyBarrierFault", false, "Show Only Barrier Fault" );
|
|
CAF_PDM_InitScriptableField( &m_showAllFaults, "ShowAllFaults", false, "Show All Faults" );
|
|
m_showAllFaults.uiCapability()->setUiEditorTypeName( caf::PdmUiToolButtonEditor::uiEditorTypeName() );
|
|
m_showAllFaults.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::HIDDEN );
|
|
|
|
CAF_PDM_InitScriptableField( &m_barrierFaultName, "BarrierFaultName", QString( "" ), "Barrier Fault" );
|
|
m_barrierFaultName.uiCapability()->setUiReadOnly( true );
|
|
|
|
CAF_PDM_InitScriptableFieldNoDefault( &m_barrierTextAnnotation, "BarrierTextAnnotation", "Barrier Text Annotation" );
|
|
|
|
CAF_PDM_InitScriptableFieldNoDefault( &m_perforationInterval, "PerforationInterval", "Perforation Interval" );
|
|
|
|
m_calculator = std::make_shared<RimStimPlanModelCalculator>();
|
|
m_calculator->setStimPlanModel( this );
|
|
|
|
setDeletable( true );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimStimPlanModel::~RimStimPlanModel()
|
|
{
|
|
RimWellPath* wellPath = m_thicknessDirectionWellPath.value();
|
|
RimWellPathCollection* wellPathCollection = RimTools::wellPathCollection();
|
|
|
|
if ( wellPath && wellPathCollection )
|
|
{
|
|
wellPathCollection->removeWellPath( wellPath );
|
|
wellPathCollection->uiCapability()->updateConnectedEditors();
|
|
wellPathCollection->scheduleRedrawAffectedViews();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimStimPlanModel::isEnabled() const
|
|
{
|
|
return isChecked();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimStimPlanModel::useDetailedFluidLoss() const
|
|
{
|
|
return m_useDetailedFluidLoss();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::initAfterRead()
|
|
{
|
|
if ( m_stimPlanModelTemplate )
|
|
{
|
|
m_stimPlanModelTemplate->changed.connect( this, &RimStimPlanModel::stimPlanModelTemplateChanged );
|
|
}
|
|
|
|
if ( m_extractionDepthTop() < 0.0 || m_extractionDepthBottom() < 0.0 )
|
|
{
|
|
updateExtractionDepthBoundaries();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
|
|
{
|
|
if ( changedField == &m_MD )
|
|
{
|
|
updatePositionFromMeasuredDepth();
|
|
}
|
|
|
|
if ( changedField == &m_MD || changedField == &m_extractionOffsetTop || changedField == &m_extractionOffsetBottom ||
|
|
changedField == &m_extractionDepthTop || changedField == &m_extractionDepthBottom )
|
|
{
|
|
updateExtractionDepthBoundaries();
|
|
}
|
|
|
|
if ( changedField == &m_MD || changedField == &m_extractionType || changedField == &m_boundingBoxVertical ||
|
|
changedField == &m_boundingBoxHorizontal || changedField == &m_fractureOrientation || changedField == &m_autoComputeBarrier ||
|
|
changedField == &m_azimuthAngle || changedField == &m_showOnlyBarrierFault || changedField == &m_eclipseCase ||
|
|
changedField == &m_extractionOffsetTop || changedField == &m_extractionOffsetBottom || changedField == &m_extractionDepthTop ||
|
|
changedField == &m_extractionDepthBottom || changedField == &m_perforationLength )
|
|
{
|
|
updateThicknessDirection();
|
|
updateBarrierProperties();
|
|
updatePerforationInterval();
|
|
}
|
|
|
|
if ( changedField == &m_eclipseCase )
|
|
{
|
|
if ( m_eclipseCase )
|
|
{
|
|
// Set a valid default time step
|
|
const int timeStepCount = m_eclipseCase->timeStepStrings().size();
|
|
if ( timeStepCount > 0 )
|
|
{
|
|
m_timeStep = timeStepCount - 1;
|
|
}
|
|
}
|
|
|
|
updateExtractionDepthBoundaries();
|
|
}
|
|
|
|
if ( changedField == &m_showAllFaults )
|
|
{
|
|
m_showAllFaults = false;
|
|
m_showOnlyBarrierFault = false;
|
|
showAllFaults();
|
|
}
|
|
|
|
if ( changedField == &m_autoComputeBarrier || changedField == &m_hasBarrier )
|
|
{
|
|
m_barrierDip.uiCapability()->setUiReadOnly( m_autoComputeBarrier || !m_hasBarrier );
|
|
m_distanceToBarrier.uiCapability()->setUiReadOnly( m_autoComputeBarrier || !m_hasBarrier );
|
|
m_showOnlyBarrierFault.uiCapability()->setUiReadOnly( !m_hasBarrier );
|
|
}
|
|
|
|
if ( changedField == &m_extractionType || changedField == &m_thicknessDirectionWellPath )
|
|
{
|
|
updateThicknessDirectionWellPathName();
|
|
m_thicknessDirectionWellPath()->updateConnectedEditors();
|
|
}
|
|
|
|
if ( changedField == &m_useDetailedFluidLoss )
|
|
{
|
|
m_relativePermeabilityFactorDefault.uiCapability()->setUiReadOnly( !m_useDetailedFluidLoss );
|
|
m_poroElasticConstantDefault.uiCapability()->setUiReadOnly( !m_useDetailedFluidLoss );
|
|
m_thermalExpansionCoeffientDefault.uiCapability()->setUiReadOnly( !m_useDetailedFluidLoss );
|
|
}
|
|
|
|
if ( changedField == &m_stimPlanModelTemplate )
|
|
{
|
|
setStimPlanModelTemplate( m_stimPlanModelTemplate() );
|
|
}
|
|
|
|
if ( changedField == &m_editStimPlanModelTemplate )
|
|
{
|
|
m_editStimPlanModelTemplate = false;
|
|
if ( m_stimPlanModelTemplate != nullptr )
|
|
{
|
|
Riu3DMainWindowTools::selectAsCurrentItem( m_stimPlanModelTemplate() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_calculator->clearCache();
|
|
updateViewsAndPlots();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QList<caf::PdmOptionItemInfo> RimStimPlanModel::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions )
|
|
{
|
|
QList<caf::PdmOptionItemInfo> options;
|
|
|
|
if ( fieldNeedingOptions == &m_stimPlanModelTemplate )
|
|
{
|
|
RimOilField* oilField = RimProject::current()->activeOilField();
|
|
if ( oilField && oilField->completionTemplateCollection() )
|
|
{
|
|
RimStimPlanModelTemplateCollection* fracDefColl = oilField->completionTemplateCollection()->stimPlanModelTemplateCollection();
|
|
|
|
for ( RimStimPlanModelTemplate* fracDef : fracDefColl->stimPlanModelTemplates() )
|
|
{
|
|
QString displayText = fracDef->name();
|
|
options.push_back( caf::PdmOptionItemInfo( displayText, fracDef ) );
|
|
}
|
|
}
|
|
}
|
|
else if ( fieldNeedingOptions == &m_eclipseCase || fieldNeedingOptions == &m_staticEclipseCase ||
|
|
fieldNeedingOptions == &m_initialPressureEclipseCase )
|
|
{
|
|
RimTools::eclipseCaseOptionItems( &options );
|
|
}
|
|
else if ( fieldNeedingOptions == &m_timeStep )
|
|
{
|
|
RimTools::timeStepsForCase( m_eclipseCase(), &options );
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Vec3d RimStimPlanModel::fracturePosition() const
|
|
{
|
|
return m_anchorPosition;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiaDefines::WellPathComponentType RimStimPlanModel::componentType() const
|
|
{
|
|
return RiaDefines::WellPathComponentType::FRACTURE;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimStimPlanModel::componentLabel() const
|
|
{
|
|
return name();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimStimPlanModel::componentTypeLabel() const
|
|
{
|
|
return "StimPlan Model";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Color3f RimStimPlanModel::defaultComponentColor() const
|
|
{
|
|
return cvf::Color3f::RED; // RiaColorTables::wellPathComponentColors()[componentType()];
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::startMD() const
|
|
{
|
|
return m_MD();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::endMD() const
|
|
{
|
|
return m_MD();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::applyOffset( double offsetMD )
|
|
{
|
|
// Nothing to do here, this operation is inteded for well path completions
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Vec3d RimStimPlanModel::anchorPosition() const
|
|
{
|
|
return m_anchorPosition();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Vec3d RimStimPlanModel::anchorPositionForUi() const
|
|
{
|
|
cvf::Vec3d v = m_anchorPosition;
|
|
v.z() = -v.z();
|
|
return v;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Vec3d RimStimPlanModel::thicknessDirection() const
|
|
{
|
|
return m_thicknessDirection();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::updatePositionFromMeasuredDepth()
|
|
{
|
|
cvf::Vec3d positionAlongWellpath = cvf::Vec3d::ZERO;
|
|
|
|
RimWellPath* wp = wellPath();
|
|
if ( wp && wp->wellPathGeometry() )
|
|
{
|
|
positionAlongWellpath = wp->wellPathGeometry()->interpolatedPointAlongWellPath( m_MD() );
|
|
}
|
|
|
|
m_anchorPosition = positionAlongWellpath;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::updateThicknessDirection()
|
|
{
|
|
cvf::Vec3d defaultDirection( 0.0, 0.0, -1.0 );
|
|
|
|
if ( m_extractionType() == ExtractionType::TRUE_STRATIGRAPHIC_THICKNESS )
|
|
{
|
|
cvf::Vec3d direction = RigStimPlanModelTools::calculateTSTDirection( getEclipseCaseData(),
|
|
m_anchorPosition(),
|
|
m_boundingBoxHorizontal,
|
|
m_boundingBoxVertical );
|
|
|
|
// Calculate an adjusted TST direction to improve the zone thickness in the well log plot.
|
|
// Using average of TST and TVD (default direction) in 3D.
|
|
m_thicknessDirection = ( direction + defaultDirection ) / 2.0;
|
|
m_originalThicknessDirection = direction;
|
|
}
|
|
else
|
|
{
|
|
// True vertical thickness: just point straight up
|
|
m_thicknessDirection = defaultDirection;
|
|
m_originalThicknessDirection = defaultDirection;
|
|
}
|
|
|
|
if ( m_thicknessDirectionWellPath )
|
|
{
|
|
RimWellPathGeometryDef* wellGeomDef = m_thicknessDirectionWellPath->geometryDefinition();
|
|
wellGeomDef->deleteAllTargets();
|
|
// Disable auto-generated target at sea level: this will usually be outside the
|
|
// bounding box, and will introduce problems when the project is reloaded.
|
|
wellGeomDef->setUseAutoGeneratedTargetAtSeaLevel( false );
|
|
|
|
cvf::Vec3d topPosition;
|
|
cvf::Vec3d bottomPosition;
|
|
|
|
if ( RigStimPlanModelTools::findThicknessTargetPoints( getEclipseCaseData(),
|
|
m_anchorPosition(),
|
|
m_thicknessDirection(),
|
|
m_extractionDepthTop(),
|
|
m_extractionDepthBottom(),
|
|
topPosition,
|
|
bottomPosition ) )
|
|
{
|
|
topPosition.z() *= -1.0;
|
|
bottomPosition.z() *= -1.0;
|
|
|
|
RimWellPathTarget* topPathTarget = new RimWellPathTarget();
|
|
topPathTarget->setAsPointTargetXYD( topPosition );
|
|
|
|
RimWellPathTarget* bottomPathTarget = new RimWellPathTarget();
|
|
bottomPathTarget->setAsPointTargetXYD( bottomPosition );
|
|
|
|
wellGeomDef->insertTarget( nullptr, topPathTarget );
|
|
wellGeomDef->insertTarget( nullptr, bottomPathTarget );
|
|
}
|
|
|
|
wellGeomDef->updateConnectedEditors();
|
|
wellGeomDef->updateWellPathVisualization( false );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::updateExtractionDepthBoundaries()
|
|
{
|
|
RigEclipseCaseData* eclipseCaseData = getEclipseCaseData();
|
|
if ( eclipseCaseData )
|
|
{
|
|
const cvf::BoundingBox& boundingBox = eclipseCaseData->mainGrid()->boundingBox();
|
|
|
|
double depth = -m_anchorPosition().z();
|
|
if ( m_extractionOffsetTop() < 0.0 ) m_extractionOffsetTop = boundingBox.extent().z();
|
|
if ( m_extractionOffsetBottom() < 0.0 ) m_extractionOffsetBottom = boundingBox.extent().z();
|
|
|
|
m_extractionDepthTop = std::max( depth - m_extractionOffsetTop, -boundingBox.max().z() );
|
|
m_extractionDepthBottom = std::min( depth + m_extractionOffsetBottom, -boundingBox.min().z() );
|
|
updateConnectedEditors();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::updateBarrierProperties()
|
|
{
|
|
if ( m_autoComputeBarrier )
|
|
{
|
|
updateDistanceToBarrierAndDip();
|
|
}
|
|
else
|
|
{
|
|
clearBarrierAnnotation();
|
|
}
|
|
|
|
if ( m_showOnlyBarrierFault() && m_hasBarrier() )
|
|
{
|
|
hideOtherFaults( m_barrierFaultName() );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::updateDistanceToBarrierAndDip()
|
|
{
|
|
if ( !wellPath() ) return;
|
|
|
|
RigEclipseCaseData* eclipseCaseData = getEclipseCaseData();
|
|
if ( !eclipseCaseData ) return;
|
|
|
|
const cvf::Vec3d& position = anchorPosition();
|
|
|
|
RiaLogging::info( "Computing distance to barrier." );
|
|
RiaLogging::info( QString( "Anchor position: %1" ).arg( RigStimPlanModelTools::vecToString( position ) ) );
|
|
|
|
cvf::Vec3d fractureDirectionNormal = computeFractureDirectionNormal( wellPath(), position );
|
|
|
|
// Update formation dip. The direction for the barrier search follows the
|
|
// inclination of the formation, and is in effect the formation dip in the
|
|
// fracture plane. -90 to convert from horizontal to vertical.
|
|
cvf::Vec3d formationDirection = projectVectorIntoFracturePlane( position, fractureDirectionNormal, m_originalThicknessDirection );
|
|
if ( formationDirection.isUndefined() ) return;
|
|
m_formationDip = std::abs( RigStimPlanModelTools::calculateFormationDip( formationDirection ) - 90.0 );
|
|
|
|
cvf::Vec3d directionToBarrier = projectVectorIntoFracturePlane( position, fractureDirectionNormal, m_thicknessDirection );
|
|
if ( directionToBarrier.isUndefined() ) return;
|
|
|
|
RiaLogging::info( QString( "Direction to barrier: %1" ).arg( RigStimPlanModelTools::vecToString( directionToBarrier ) ) );
|
|
|
|
auto [foundFault, shortestDistance, barrierPosition, barrierDip] =
|
|
RigStimPlanModelTools::findClosestFaultBarrier( eclipseCaseData, position, directionToBarrier );
|
|
|
|
if ( foundFault )
|
|
{
|
|
RiaLogging::info(
|
|
QString( "Found barrier distance: %1. Dip: %2. Fault: %3" ).arg( shortestDistance ).arg( barrierDip ).arg( foundFault->name() ) );
|
|
QString barrierText =
|
|
QString( "Barrier Fault for %1\nFault: %2\nDistance: %3m" ).arg( name() ).arg( foundFault->name() ).arg( shortestDistance );
|
|
|
|
clearBarrierAnnotation();
|
|
addBarrierAnnotation( position, barrierPosition, barrierText );
|
|
|
|
m_hasBarrier = true;
|
|
m_barrierDip = barrierDip;
|
|
m_distanceToBarrier = shortestDistance;
|
|
m_barrierFaultName = foundFault->name();
|
|
}
|
|
else
|
|
{
|
|
RiaLogging::info( "No barrier found." );
|
|
clearBarrierAnnotation();
|
|
m_hasBarrier = false;
|
|
m_barrierDip = 0.0;
|
|
m_distanceToBarrier = 0.0;
|
|
m_barrierFaultName = "";
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Vec3d RimStimPlanModel::computeFractureDirectionNormal( RimWellPath* wellPath, const cvf::Vec3d& position ) const
|
|
{
|
|
CAF_ASSERT( wellPath );
|
|
RigWellPath* wellPathGeometry = wellPath->wellPathGeometry();
|
|
CAF_ASSERT( wellPathGeometry );
|
|
|
|
// Find the well path points closest to the anchor position
|
|
cvf::Vec3d p1;
|
|
cvf::Vec3d p2;
|
|
wellPathGeometry->twoClosestPoints( position, &p1, &p2 );
|
|
RiaLogging::info( QString( "Closest points on well path: %1 %2" )
|
|
.arg( RigStimPlanModelTools::vecToString( p1 ) )
|
|
.arg( RigStimPlanModelTools::vecToString( p2 ) ) );
|
|
|
|
// Create a well direction based on the two points
|
|
cvf::Vec3d wellDirection = ( p2 - p1 ).getNormalized();
|
|
RiaLogging::info( QString( "Well direction: %1" ).arg( RigStimPlanModelTools::vecToString( wellDirection ) ) );
|
|
|
|
cvf::Vec3d fractureDirectionNormal = wellDirection;
|
|
if ( m_fractureOrientation == FractureOrientation::ALONG_WELL_PATH )
|
|
{
|
|
cvf::Mat3d azimuthRotation = cvf::Mat3d::fromRotation( cvf::Vec3d::Z_AXIS, cvf::Math::toRadians( 90.0 ) );
|
|
fractureDirectionNormal.transformVector( azimuthRotation );
|
|
}
|
|
else if ( m_fractureOrientation == FractureOrientation::AZIMUTH )
|
|
{
|
|
// Azimuth angle of fracture is relative to north.
|
|
double wellAzimuth = wellPathGeometry->wellPathAzimuthAngle( position );
|
|
cvf::Mat3d azimuthRotation =
|
|
cvf::Mat3d::fromRotation( cvf::Vec3d::Z_AXIS, cvf::Math::toRadians( wellAzimuth - m_azimuthAngle() - 90.0 ) );
|
|
fractureDirectionNormal.transformVector( azimuthRotation );
|
|
}
|
|
|
|
return fractureDirectionNormal;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Vec3d RimStimPlanModel::projectVectorIntoFracturePlane( const cvf::Vec3d& position,
|
|
const cvf::Vec3d& fractureDirectionNormal,
|
|
const cvf::Vec3d& direction )
|
|
{
|
|
// Create a fracture plane
|
|
cvf::Plane fracturePlane;
|
|
if ( !fracturePlane.setFromPointAndNormal( position, fractureDirectionNormal ) )
|
|
{
|
|
RiaLogging::error( "Unable to create fracture plane" );
|
|
return cvf::Vec3d::UNDEFINED;
|
|
}
|
|
|
|
// Project the direction onto the fracture plane.
|
|
cvf::Vec3d tstInPlane;
|
|
if ( !fracturePlane.projectVector( direction, &tstInPlane ) )
|
|
{
|
|
RiaLogging::error( "Unable to project thickess vector into fracture plane" );
|
|
return cvf::Vec3d::UNDEFINED;
|
|
}
|
|
|
|
// The direction to the barrier is normal to the TST project into the fracture plane
|
|
cvf::Vec3d directionInPlane = ( tstInPlane ^ fractureDirectionNormal ).getNormalized();
|
|
return directionInPlane;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::clearBarrierAnnotation()
|
|
{
|
|
RimAnnotationCollectionBase* coll = annotationCollection();
|
|
|
|
auto existingTextAnnotation = m_barrierTextAnnotation.value();
|
|
if ( coll && existingTextAnnotation )
|
|
{
|
|
coll->removeAnnotation( existingTextAnnotation );
|
|
delete existingTextAnnotation;
|
|
m_barrierTextAnnotation = nullptr;
|
|
coll->onAnnotationDeleted();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::addBarrierAnnotation( const cvf::Vec3d& startPosition, const cvf::Vec3d& endPosition, const QString& text )
|
|
{
|
|
RimAnnotationCollectionBase* coll = annotationCollection();
|
|
if ( !coll ) return;
|
|
|
|
auto newAnnotation = new RimTextAnnotation();
|
|
newAnnotation->setText( text );
|
|
newAnnotation->setLabelPoint( endPosition );
|
|
newAnnotation->setAnchorPoint( startPosition );
|
|
|
|
m_barrierTextAnnotation = newAnnotation;
|
|
|
|
coll->addAnnotation( newAnnotation );
|
|
coll->scheduleRedrawOfRelevantViews();
|
|
coll->updateConnectedEditors();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimAnnotationCollectionBase* RimStimPlanModel::annotationCollection()
|
|
{
|
|
const auto project = RimProject::current();
|
|
auto oilField = project->activeOilField();
|
|
return oilField ? oilField->annotationCollection() : nullptr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::updatePerforationInterval()
|
|
{
|
|
if ( !m_thicknessDirectionWellPath || !wellPath() || !wellPath()->wellPathGeometry() ) return;
|
|
|
|
if ( !m_perforationInterval )
|
|
{
|
|
m_perforationInterval = new RimPerforationInterval;
|
|
m_perforationInterval->setUnitSystemSpecificDefaults();
|
|
m_thicknessDirectionWellPath->perforationIntervalCollection()->appendPerforation( m_perforationInterval );
|
|
}
|
|
|
|
double halfPerforationLength = m_perforationLength() * 0.5;
|
|
if ( m_fractureOrientation == FractureOrientation::ALONG_WELL_PATH )
|
|
{
|
|
// Adjust perforation interval for longitudinal fractures to correct TVD depth
|
|
cvf::Vec3d wellPathTangent = wellPath()->wellPathGeometry()->tangentAlongWellPath( m_MD() );
|
|
halfPerforationLength = RigStimPlanModelTools::calculatePerforationLength( wellPathTangent, m_perforationLength() ) * 0.5;
|
|
}
|
|
|
|
double closestMd = m_thicknessDirectionWellPath->wellPathGeometry()->closestMeasuredDepth( m_anchorPosition );
|
|
m_perforationInterval->setStartAndEndMD( closestMd - halfPerforationLength, closestMd + halfPerforationLength );
|
|
m_perforationInterval->updateConnectedEditors();
|
|
updateViewsAndPlots();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
|
|
{
|
|
m_thicknessDirectionWellPath.uiCapability()->setUiHidden( true );
|
|
m_barrierTextAnnotation.uiCapability()->setUiHidden( true );
|
|
m_azimuthAngle.uiCapability()->setUiHidden( m_fractureOrientation() != RimStimPlanModel::FractureOrientation::AZIMUTH );
|
|
|
|
uiOrdering.add( nameField(), { .newRow = true, .totalColumnSpan = 3, .leftLabelColumnSpan = 1 } );
|
|
uiOrdering.add( &m_stimPlanModelTemplate, { .newRow = true, .totalColumnSpan = 2, .leftLabelColumnSpan = 1 } );
|
|
uiOrdering.add( &m_editStimPlanModelTemplate, { .newRow = false, .totalColumnSpan = 1, .leftLabelColumnSpan = 0 } );
|
|
|
|
uiOrdering.add( &m_staticEclipseCase );
|
|
|
|
caf::PdmUiOrdering* pressureDataSourceGroup = uiOrdering.addNewGroup( "Pressure Data Source" );
|
|
pressureDataSourceGroup->add( &m_eclipseCase );
|
|
pressureDataSourceGroup->add( &m_timeStep );
|
|
pressureDataSourceGroup->add( &m_initialPressureEclipseCase );
|
|
|
|
uiOrdering.add( &m_MD );
|
|
uiOrdering.add( &m_extractionType );
|
|
uiOrdering.add( &m_anchorPositionForUi );
|
|
uiOrdering.add( &m_thicknessDirection );
|
|
|
|
caf::PdmUiOrdering* extractionBoundariesGroup = uiOrdering.addNewGroup( "Extraction Depth Boundaries" );
|
|
extractionBoundariesGroup->add( &m_extractionOffsetTop, { .newRow = true, .totalColumnSpan = 3, .leftLabelColumnSpan = 1 } );
|
|
extractionBoundariesGroup->add( &m_extractionDepthTop, { .newRow = false, .totalColumnSpan = 2, .leftLabelColumnSpan = 1 } );
|
|
|
|
extractionBoundariesGroup->add( &m_extractionOffsetBottom, { .newRow = true, .totalColumnSpan = 3, .leftLabelColumnSpan = 1 } );
|
|
extractionBoundariesGroup->add( &m_extractionDepthBottom, { .newRow = false, .totalColumnSpan = 2, .leftLabelColumnSpan = 1 } );
|
|
|
|
caf::PdmUiOrdering* boundingBoxGroup = uiOrdering.addNewGroup( "Bounding Box" );
|
|
boundingBoxGroup->add( &m_boundingBoxHorizontal );
|
|
boundingBoxGroup->add( &m_boundingBoxVertical );
|
|
|
|
caf::PdmUiOrdering* detailedFluidLossGroup = uiOrdering.addNewGroup( "Detailed Fluid Loss" );
|
|
detailedFluidLossGroup->add( &m_useDetailedFluidLoss );
|
|
detailedFluidLossGroup->add( &m_relativePermeabilityFactorDefault );
|
|
detailedFluidLossGroup->add( &m_poroElasticConstantDefault );
|
|
detailedFluidLossGroup->add( &m_thermalExpansionCoeffientDefault );
|
|
|
|
caf::PdmUiOrdering* perforationGroup = uiOrdering.addNewGroup( "Perforation" );
|
|
perforationGroup->add( &m_perforationLength );
|
|
perforationGroup->add( &m_fractureOrientation );
|
|
perforationGroup->add( &m_azimuthAngle );
|
|
|
|
caf::PdmUiOrdering* asymmetricGroup = uiOrdering.addNewGroup( "Asymmetric" );
|
|
asymmetricGroup->add( &m_formationDip );
|
|
asymmetricGroup->add( &m_hasBarrier );
|
|
asymmetricGroup->add( &m_autoComputeBarrier );
|
|
asymmetricGroup->add( &m_distanceToBarrier );
|
|
asymmetricGroup->add( &m_barrierDip );
|
|
asymmetricGroup->add( &m_barrierFaultName );
|
|
|
|
asymmetricGroup->add( &m_showOnlyBarrierFault, { .newRow = true, .totalColumnSpan = 2, .leftLabelColumnSpan = 1 } );
|
|
asymmetricGroup->add( &m_showAllFaults, { .newRow = false, .totalColumnSpan = 1, .leftLabelColumnSpan = 0 } );
|
|
|
|
asymmetricGroup->add( &m_wellPenetrationLayer );
|
|
|
|
uiOrdering.skipRemainingFields();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::defineEditorAttribute( const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute )
|
|
{
|
|
if ( field == &m_formationDip || field == &m_barrierDip || field == &m_distanceToBarrier )
|
|
{
|
|
caf::PdmUiDoubleValueEditorAttribute::testAndSetFixedWithTwoDecimals( attribute );
|
|
}
|
|
|
|
if ( field == &m_MD )
|
|
{
|
|
caf::PdmUiDoubleSliderEditorAttribute* myAttr = dynamic_cast<caf::PdmUiDoubleSliderEditorAttribute*>( attribute );
|
|
|
|
if ( myAttr )
|
|
{
|
|
if ( !wellPath() ) return;
|
|
|
|
myAttr->m_minimum = wellPath()->startMD();
|
|
myAttr->m_maximum = wellPath()->endMD();
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimWellPath* RimStimPlanModel::wellPath() const
|
|
{
|
|
const caf::PdmObjectHandle* objHandle = dynamic_cast<const caf::PdmObjectHandle*>( this );
|
|
if ( !objHandle ) return nullptr;
|
|
|
|
return objHandle->firstAncestorOrThisOfType<RimWellPath>();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimModeledWellPath* RimStimPlanModel::thicknessDirectionWellPath() const
|
|
{
|
|
return m_thicknessDirectionWellPath;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::setThicknessDirectionWellPath( RimModeledWellPath* thicknessDirectionWellPath )
|
|
{
|
|
m_thicknessDirectionWellPath = thicknessDirectionWellPath;
|
|
updateThicknessDirectionWellPathName();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::updateThicknessDirectionWellPathName()
|
|
{
|
|
QString wellNameFormat( "%1 for %2" );
|
|
m_thicknessDirectionWellPath()->setName( wellNameFormat.arg( m_extractionType().text() ).arg( name() ) );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::loadDataAndUpdate()
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::resetAnchorPositionAndThicknessDirection()
|
|
{
|
|
// Always recompute thickness direction as MD in project file might have been changed
|
|
updatePositionFromMeasuredDepth();
|
|
updateExtractionDepthBoundaries();
|
|
updateThicknessDirection();
|
|
updatePerforationInterval();
|
|
updateBarrierProperties();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::defaultPorosity() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->defaultPorosity() : RiaDefines::defaultPorosity();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::defaultPermeability() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->defaultPermeability() : RiaDefines::defaultPermeability();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::defaultFaciesValue() const
|
|
{
|
|
RimStimPlanModelTemplate* templ = m_stimPlanModelTemplate();
|
|
if ( templ )
|
|
{
|
|
// Map the facies to a value using the color legend
|
|
RimFaciesProperties* faciesProperties = templ->faciesProperties();
|
|
if ( faciesProperties )
|
|
{
|
|
RimColorLegend* faciesColorLegend = faciesProperties->colorLegend();
|
|
if ( faciesColorLegend )
|
|
{
|
|
return findFaciesValue( *faciesColorLegend, templ->defaultFacies() );
|
|
}
|
|
}
|
|
}
|
|
|
|
return std::numeric_limits<double>::infinity();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::getDefaultForMissingValue( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::POROSITY || curveProperty == RiaDefines::CurveProperty::POROSITY_UNSCALED )
|
|
{
|
|
return defaultPorosity();
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::PERMEABILITY_X || curveProperty == RiaDefines::CurveProperty::PERMEABILITY_Z )
|
|
{
|
|
return defaultPermeability();
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::NET_TO_GROSS )
|
|
{
|
|
return 1.0;
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::FACIES )
|
|
{
|
|
return defaultFaciesValue();
|
|
}
|
|
else
|
|
{
|
|
return std::numeric_limits<double>::infinity();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiaDefines::CurveProperty RimStimPlanModel::getDefaultPropertyForMissingValues( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::PRESSURE )
|
|
{
|
|
return RiaDefines::CurveProperty::INITIAL_PRESSURE;
|
|
}
|
|
|
|
return RiaDefines::CurveProperty::UNDEFINED;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::getDefaultForMissingOverburdenValue( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::POROSITY || curveProperty == RiaDefines::CurveProperty::POROSITY_UNSCALED )
|
|
{
|
|
return defaultOverburdenPorosity();
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::PERMEABILITY_X || curveProperty == RiaDefines::CurveProperty::PERMEABILITY_Z )
|
|
{
|
|
return defaultOverburdenPermeability();
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::FACIES )
|
|
{
|
|
RimColorLegend* faciesColorLegend = getFaciesColorLegend();
|
|
if ( !faciesColorLegend ) return std::numeric_limits<double>::infinity();
|
|
return findFaciesValue( *faciesColorLegend, overburdenFacies() );
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::NET_TO_GROSS )
|
|
{
|
|
return 1.0;
|
|
}
|
|
else
|
|
{
|
|
return std::numeric_limits<double>::infinity();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::getDefaultForMissingUnderburdenValue( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::POROSITY || curveProperty == RiaDefines::CurveProperty::POROSITY_UNSCALED )
|
|
{
|
|
return defaultUnderburdenPorosity();
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::PERMEABILITY_X || curveProperty == RiaDefines::CurveProperty::PERMEABILITY_Z )
|
|
{
|
|
return defaultUnderburdenPermeability();
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::FACIES )
|
|
{
|
|
RimColorLegend* faciesColorLegend = getFaciesColorLegend();
|
|
if ( !faciesColorLegend ) return std::numeric_limits<double>::infinity();
|
|
return findFaciesValue( *faciesColorLegend, underburdenFacies() );
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::NET_TO_GROSS )
|
|
{
|
|
return 1.0;
|
|
}
|
|
else
|
|
{
|
|
return std::numeric_limits<double>::infinity();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::getOverburdenGradient( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::PRESSURE || curveProperty == RiaDefines::CurveProperty::INITIAL_PRESSURE )
|
|
{
|
|
if ( !m_stimPlanModelTemplate )
|
|
{
|
|
return 0.0;
|
|
}
|
|
return m_stimPlanModelTemplate()->overburdenFluidDensity() * 9.81 * 1000.0 / 1.0e5;
|
|
}
|
|
else
|
|
{
|
|
RiaLogging::error(
|
|
QString( "Missing overburden gradient for %1." ).arg( caf::AppEnum<RiaDefines::CurveProperty>( curveProperty ).uiText() ) );
|
|
return std::numeric_limits<double>::infinity();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::getUnderburdenGradient( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::PRESSURE || curveProperty == RiaDefines::CurveProperty::INITIAL_PRESSURE )
|
|
{
|
|
if ( !m_stimPlanModelTemplate )
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
return m_stimPlanModelTemplate()->underburdenFluidDensity() * 9.81 * 1000.0 / 1.0e5;
|
|
}
|
|
else
|
|
{
|
|
RiaLogging::error(
|
|
QString( "Missing underburden gradient for %1." ).arg( caf::AppEnum<RiaDefines::CurveProperty>( curveProperty ).uiText() ) );
|
|
return std::numeric_limits<double>::infinity();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::getDefaultValueForProperty( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::RELATIVE_PERMEABILITY_FACTOR )
|
|
{
|
|
return m_relativePermeabilityFactorDefault;
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::PORO_ELASTIC_CONSTANT )
|
|
{
|
|
return m_poroElasticConstantDefault;
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::THERMAL_EXPANSION_COEFFICIENT )
|
|
{
|
|
return m_thermalExpansionCoeffientDefault;
|
|
}
|
|
else
|
|
{
|
|
RiaLogging::error( QString( "Missing default for %1." ).arg( caf::AppEnum<RiaDefines::CurveProperty>( curveProperty ).uiText() ) );
|
|
return std::numeric_limits<double>::infinity();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::deque<RimStimPlanModel::MissingValueStrategy> RimStimPlanModel::missingValueStrategies( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::PRESSURE )
|
|
return { RimStimPlanModel::MissingValueStrategy::OTHER_CURVE_PROPERTY };
|
|
else if ( curveProperty == RiaDefines::CurveProperty::EQLNUM )
|
|
return { RimStimPlanModel::MissingValueStrategy::DEFAULT_VALUE,
|
|
RimStimPlanModel::MissingValueStrategy::CELLS_ABOVE,
|
|
RimStimPlanModel::MissingValueStrategy::CELLS_BELOW,
|
|
RimStimPlanModel::MissingValueStrategy::LINEAR_INTERPOLATION };
|
|
else
|
|
return { RimStimPlanModel::MissingValueStrategy::DEFAULT_VALUE };
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimStimPlanModel::BurdenStrategy RimStimPlanModel::burdenStrategy( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::INITIAL_PRESSURE ) return RimStimPlanModel::BurdenStrategy::GRADIENT;
|
|
|
|
return RimStimPlanModel::BurdenStrategy::DEFAULT_VALUE;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimStimPlanModel::hasDefaultValueForProperty( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
auto withDefaults = { RiaDefines::CurveProperty::RELATIVE_PERMEABILITY_FACTOR,
|
|
RiaDefines::CurveProperty::PORO_ELASTIC_CONSTANT,
|
|
RiaDefines::CurveProperty::THERMAL_EXPANSION_COEFFICIENT };
|
|
return std::find( withDefaults.begin(), withDefaults.end(), curveProperty ) != withDefaults.end();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::verticalStress() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->verticalStress() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::verticalStressGradient() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->verticalStressGradient() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::stressDepth() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->stressDepth() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::overburdenHeight() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->overburdenHeight() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::underburdenHeight() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->underburdenHeight() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::defaultOverburdenPorosity() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->defaultOverburdenPorosity() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::defaultUnderburdenPorosity() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->defaultUnderburdenPorosity() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::defaultOverburdenPermeability() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->defaultOverburdenPermeability() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::defaultUnderburdenPermeability() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->defaultUnderburdenPermeability() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimStimPlanModel::overburdenFormation() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->overburdenFormation() : "";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimStimPlanModel::overburdenFacies() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->overburdenFacies() : "";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimStimPlanModel::underburdenFormation() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->underburdenFormation() : "";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimStimPlanModel::underburdenFacies() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->underburdenFacies() : "";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::updateReferringPlots()
|
|
{
|
|
// Update plots referring to this fracture model
|
|
std::vector<RimStimPlanModelPlot*> referringObjects = objectsWithReferringPtrFieldsOfType<RimStimPlanModelPlot>();
|
|
|
|
for ( auto modelPlot : referringObjects )
|
|
{
|
|
if ( modelPlot ) modelPlot->loadDataAndUpdate();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::setMD( double md )
|
|
{
|
|
m_MD = md;
|
|
updatePositionFromMeasuredDepth();
|
|
updateExtractionDepthBoundaries();
|
|
updateThicknessDirection();
|
|
updatePerforationInterval();
|
|
updateBarrierProperties();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::setEclipseCaseAndTimeStep( RimEclipseCase* eclipseCase, int timeStep )
|
|
{
|
|
setEclipseCase( eclipseCase );
|
|
setTimeStep( timeStep );
|
|
updateExtractionDepthBoundaries();
|
|
updateThicknessDirection();
|
|
updatePerforationInterval();
|
|
updateBarrierProperties();
|
|
updateViewsAndPlots();
|
|
updateConnectedEditors();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
int RimStimPlanModel::timeStep() const
|
|
{
|
|
return m_timeStep;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::setTimeStep( int timeStep )
|
|
{
|
|
m_timeStep = timeStep;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::referenceTemperature() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->referenceTemperature() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::referenceTemperatureGradient() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->referenceTemperatureGradient() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::referenceTemperatureDepth() const
|
|
{
|
|
return m_stimPlanModelTemplate() ? m_stimPlanModelTemplate()->referenceTemperatureDepth() : 0.0;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimStimPlanModel::useStaticEclipseCase( RiaDefines::CurveProperty curveProperty )
|
|
{
|
|
std::vector<RiaDefines::CurveProperty> matching = {
|
|
RiaDefines::CurveProperty::POROSITY,
|
|
RiaDefines::CurveProperty::POROSITY_UNSCALED,
|
|
RiaDefines::CurveProperty::PERMEABILITY_X,
|
|
RiaDefines::CurveProperty::PERMEABILITY_Z,
|
|
RiaDefines::CurveProperty::FACIES,
|
|
RiaDefines::CurveProperty::NET_TO_GROSS,
|
|
RiaDefines::CurveProperty::EQLNUM,
|
|
};
|
|
|
|
return std::find( matching.begin(), matching.end(), curveProperty ) != matching.end();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimEclipseCase* RimStimPlanModel::eclipseCaseForProperty( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( m_initialPressureEclipseCase &&
|
|
( curveProperty == RiaDefines::CurveProperty::INITIAL_PRESSURE || curveProperty == RiaDefines::CurveProperty::EQLNUM ) )
|
|
{
|
|
return m_initialPressureEclipseCase;
|
|
}
|
|
else if ( m_staticEclipseCase && useStaticEclipseCase( curveProperty ) )
|
|
{
|
|
return m_staticEclipseCase;
|
|
}
|
|
else
|
|
{
|
|
return m_eclipseCase;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::setEclipseCase( RimEclipseCase* eclipseCase )
|
|
{
|
|
if ( m_stimPlanModelTemplate )
|
|
{
|
|
m_stimPlanModelTemplate->setDynamicEclipseCase( eclipseCase );
|
|
m_stimPlanModelTemplate->setInitialPressureEclipseCase( eclipseCase );
|
|
m_stimPlanModelTemplate->setStaticEclipseCase( eclipseCase );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RigEclipseCaseData* RimStimPlanModel::getEclipseCaseData() const
|
|
{
|
|
// Find an eclipse case
|
|
RimEclipseCase* eclCase = eclipseCaseForProperty( RiaDefines::CurveProperty::FACIES );
|
|
if ( !eclCase ) return nullptr;
|
|
|
|
return eclCase->eclipseCaseData();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::perforationLength() const
|
|
{
|
|
return m_perforationLength();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimStimPlanModel::FractureOrientation RimStimPlanModel::fractureOrientation() const
|
|
{
|
|
return m_fractureOrientation();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::formationDip() const
|
|
{
|
|
return m_formationDip;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimStimPlanModel::hasBarrier() const
|
|
{
|
|
return m_hasBarrier;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::distanceToBarrier() const
|
|
{
|
|
return m_distanceToBarrier;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::barrierDip() const
|
|
{
|
|
return m_barrierDip;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
int RimStimPlanModel::wellPenetrationLayer() const
|
|
{
|
|
return m_wellPenetrationLayer;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::setStimPlanModelTemplate( RimStimPlanModelTemplate* stimPlanModelTemplate )
|
|
{
|
|
if ( m_stimPlanModelTemplate )
|
|
{
|
|
m_stimPlanModelTemplate->changed.disconnect( this );
|
|
}
|
|
|
|
m_stimPlanModelTemplate = stimPlanModelTemplate;
|
|
stimPlanModelTemplateChanged( nullptr );
|
|
|
|
if ( m_stimPlanModelTemplate )
|
|
{
|
|
m_stimPlanModelTemplate->changed.connect( this, &RimStimPlanModel::stimPlanModelTemplateChanged );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimStimPlanModelTemplate* RimStimPlanModel::stimPlanModelTemplate() const
|
|
{
|
|
return m_stimPlanModelTemplate;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::stimPlanModelTemplateChanged( const caf::SignalEmitter* emitter )
|
|
{
|
|
m_calculator->clearCache();
|
|
|
|
if ( m_stimPlanModelTemplate() )
|
|
{
|
|
m_eclipseCase = m_stimPlanModelTemplate()->dynamicEclipseCase();
|
|
m_timeStep = m_stimPlanModelTemplate()->timeStep();
|
|
m_initialPressureEclipseCase = m_stimPlanModelTemplate()->initialPressureEclipseCase();
|
|
m_staticEclipseCase = m_stimPlanModelTemplate()->staticEclipseCase();
|
|
updateExtractionDepthBoundaries();
|
|
updateThicknessDirection();
|
|
updatePerforationInterval();
|
|
updateBarrierProperties();
|
|
}
|
|
|
|
updateViewsAndPlots();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::updateViewsAndPlots()
|
|
{
|
|
auto eclipseCase = firstAncestorOrThisOfType<RimEclipseCase>();
|
|
if ( eclipseCase )
|
|
{
|
|
RiaCompletionTypeCalculationScheduler::instance()->scheduleRecalculateCompletionTypeAndRedrawAllViews( { eclipseCase } );
|
|
}
|
|
else
|
|
{
|
|
RiaCompletionTypeCalculationScheduler::instance()->scheduleRecalculateCompletionTypeAndRedrawAllViews();
|
|
}
|
|
|
|
RimProject::current()->scheduleCreateDisplayModelAndRedrawAllViews();
|
|
|
|
updateReferringPlots();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::hideOtherFaults( const QString& targetFaultName )
|
|
{
|
|
RimEclipseView* view = dynamic_cast<RimEclipseView*>( RiaApplication::instance()->activeReservoirView() );
|
|
if ( !view ) return;
|
|
|
|
RimFaultInViewCollection* faultCollection = view->faultCollection();
|
|
if ( !faultCollection ) return;
|
|
|
|
for ( RimFaultInView* rimFault : faultCollection->faults() )
|
|
{
|
|
rimFault->showFault = ( rimFault->name() == targetFaultName );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RimStimPlanModel::showAllFaults()
|
|
{
|
|
RimEclipseView* view = dynamic_cast<RimEclipseView*>( RiaApplication::instance()->activeReservoirView() );
|
|
if ( !view ) return;
|
|
|
|
RimFaultInViewCollection* faultCollection = view->faultCollection();
|
|
if ( !faultCollection ) return;
|
|
|
|
for ( RimFaultInView* rimFault : faultCollection->faults() )
|
|
{
|
|
rimFault->showFault = true;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::shared_ptr<RimStimPlanModelCalculator> RimStimPlanModel::calculator() const
|
|
{
|
|
return m_calculator;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiaDefines::ResultCatType RimStimPlanModel::eclipseResultCategory( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::PRESSURE || curveProperty == RiaDefines::CurveProperty::INITIAL_PRESSURE )
|
|
{
|
|
return RiaDefines::ResultCatType::DYNAMIC_NATIVE;
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::FACIES )
|
|
{
|
|
if ( !m_stimPlanModelTemplate ) return RiaDefines::ResultCatType::STATIC_NATIVE;
|
|
|
|
RimFaciesProperties* faciesProperties = m_stimPlanModelTemplate->faciesProperties();
|
|
if ( !faciesProperties ) return RiaDefines::ResultCatType::STATIC_NATIVE;
|
|
|
|
const RimEclipseResultDefinition* faciesDefinition = faciesProperties->faciesDefinition();
|
|
if ( !faciesDefinition ) return RiaDefines::ResultCatType::STATIC_NATIVE;
|
|
|
|
return faciesDefinition->resultType();
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::NET_TO_GROSS )
|
|
{
|
|
if ( !m_stimPlanModelTemplate ) return RiaDefines::ResultCatType::STATIC_NATIVE;
|
|
|
|
RimNonNetLayers* nonNetLayers = m_stimPlanModelTemplate->nonNetLayers();
|
|
if ( !nonNetLayers ) return RiaDefines::ResultCatType::STATIC_NATIVE;
|
|
|
|
const RimEclipseResultDefinition* resultDef = nonNetLayers->resultDefinition();
|
|
if ( !resultDef ) return RiaDefines::ResultCatType::STATIC_NATIVE;
|
|
|
|
return resultDef->resultType();
|
|
}
|
|
else
|
|
{
|
|
return RiaDefines::ResultCatType::STATIC_NATIVE;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimStimPlanModel::eclipseResultVariable( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::PRESSURE || curveProperty == RiaDefines::CurveProperty::INITIAL_PRESSURE )
|
|
return "PRESSURE";
|
|
else if ( curveProperty == RiaDefines::CurveProperty::EQLNUM )
|
|
return "EQLNUM";
|
|
else if ( curveProperty == RiaDefines::CurveProperty::PERMEABILITY_X )
|
|
return "PERMX";
|
|
else if ( curveProperty == RiaDefines::CurveProperty::PERMEABILITY_Z )
|
|
return "PERMZ";
|
|
else if ( curveProperty == RiaDefines::CurveProperty::POROSITY || curveProperty == RiaDefines::CurveProperty::POROSITY_UNSCALED )
|
|
return "PORO";
|
|
else if ( curveProperty == RiaDefines::CurveProperty::FACIES )
|
|
{
|
|
if ( !m_stimPlanModelTemplate ) return "";
|
|
|
|
RimFaciesProperties* faciesProperties = m_stimPlanModelTemplate->faciesProperties();
|
|
if ( !faciesProperties ) return "";
|
|
|
|
const RimEclipseResultDefinition* faciesDefinition = faciesProperties->faciesDefinition();
|
|
if ( !faciesDefinition ) return "";
|
|
|
|
return faciesDefinition->resultVariable();
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::NET_TO_GROSS )
|
|
{
|
|
if ( !m_stimPlanModelTemplate ) return "";
|
|
|
|
RimNonNetLayers* nonNetLayers = m_stimPlanModelTemplate->nonNetLayers();
|
|
if ( !nonNetLayers ) return "";
|
|
|
|
const RimEclipseResultDefinition* resultDef = nonNetLayers->resultDefinition();
|
|
if ( !resultDef ) return "";
|
|
|
|
return resultDef->resultVariable();
|
|
}
|
|
else
|
|
return "";
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RimColorLegend* RimStimPlanModel::getFaciesColorLegend() const
|
|
{
|
|
if ( !m_stimPlanModelTemplate ) return nullptr;
|
|
|
|
RimFaciesProperties* faciesProperties = m_stimPlanModelTemplate->faciesProperties();
|
|
if ( !faciesProperties ) return nullptr;
|
|
|
|
return faciesProperties->colorLegend();
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double RimStimPlanModel::findFaciesValue( const RimColorLegend& colorLegend, const QString& name )
|
|
{
|
|
for ( auto item : colorLegend.colorLegendItems() )
|
|
{
|
|
if ( item->categoryName().compare( name, Qt::CaseInsensitive ) == 0 ) return item->categoryValue();
|
|
}
|
|
|
|
return std::numeric_limits<double>::infinity();
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RimStimPlanModel::isScaledByNetToGross( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
std::vector<RiaDefines::CurveProperty> matching = { RiaDefines::CurveProperty::POROSITY,
|
|
RiaDefines::CurveProperty::PERMEABILITY_X,
|
|
RiaDefines::CurveProperty::PERMEABILITY_Z,
|
|
RiaDefines::CurveProperty::YOUNGS_MODULUS,
|
|
RiaDefines::CurveProperty::POISSONS_RATIO,
|
|
RiaDefines::CurveProperty::BIOT_COEFFICIENT,
|
|
RiaDefines::CurveProperty::K0,
|
|
RiaDefines::CurveProperty::K_IC,
|
|
RiaDefines::CurveProperty::PROPPANT_EMBEDMENT,
|
|
RiaDefines::CurveProperty::FLUID_LOSS_COEFFICIENT,
|
|
RiaDefines::CurveProperty::SPURT_LOSS,
|
|
RiaDefines::CurveProperty::RELATIVE_PERMEABILITY_FACTOR,
|
|
RiaDefines::CurveProperty::PORO_ELASTIC_CONSTANT,
|
|
RiaDefines::CurveProperty::THERMAL_EXPANSION_COEFFICIENT,
|
|
RiaDefines::CurveProperty::IMMOBILE_FLUID_SATURATION };
|
|
|
|
return std::find( matching.begin(), matching.end(), curveProperty ) != matching.end();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimStimPlanModel::pressureDate() const
|
|
{
|
|
if ( !m_stimPlanModelTemplate ) return QString();
|
|
|
|
if ( m_stimPlanModelTemplate->usePressureTableForProperty( RiaDefines::CurveProperty::PRESSURE ) )
|
|
return m_stimPlanModelTemplate->pressureTable()->pressureDate();
|
|
else if ( m_eclipseCase && m_timeStep >= 0 && m_timeStep < m_eclipseCase->timeStepStrings().size() )
|
|
return m_eclipseCase->timeStepStrings()[m_timeStep];
|
|
else
|
|
return QString();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::deque<RimExtractionConfiguration> RimStimPlanModel::extractionConfigurations( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
if ( curveProperty == RiaDefines::CurveProperty::EQLNUM )
|
|
{
|
|
return {
|
|
RimExtractionConfiguration( "EQLNUM_1",
|
|
RiaDefines::ResultCatType::INPUT_PROPERTY,
|
|
RimExtractionConfiguration::EclipseCaseType::INITIAL_PRESSURE_CASE ),
|
|
RimExtractionConfiguration( "EQLNUM",
|
|
RiaDefines::ResultCatType::INPUT_PROPERTY,
|
|
RimExtractionConfiguration::EclipseCaseType::INITIAL_PRESSURE_CASE ),
|
|
RimExtractionConfiguration( "EQLNUM_1",
|
|
RiaDefines::ResultCatType::INPUT_PROPERTY,
|
|
RimExtractionConfiguration::EclipseCaseType::DYNAMIC_CASE ),
|
|
RimExtractionConfiguration( "EQLNUM",
|
|
RiaDefines::ResultCatType::INPUT_PROPERTY,
|
|
RimExtractionConfiguration::EclipseCaseType::DYNAMIC_CASE ),
|
|
RimExtractionConfiguration( "EQLNUM_1",
|
|
RiaDefines::ResultCatType::INPUT_PROPERTY,
|
|
RimExtractionConfiguration::EclipseCaseType::STATIC_CASE ),
|
|
RimExtractionConfiguration( "EQLNUM",
|
|
RiaDefines::ResultCatType::INPUT_PROPERTY,
|
|
RimExtractionConfiguration::EclipseCaseType::STATIC_CASE ),
|
|
RimExtractionConfiguration( "EQLNUM",
|
|
RiaDefines::ResultCatType::STATIC_NATIVE,
|
|
RimExtractionConfiguration::EclipseCaseType::STATIC_CASE ),
|
|
RimExtractionConfiguration( "EQLNUM",
|
|
RiaDefines::ResultCatType::STATIC_NATIVE,
|
|
RimExtractionConfiguration::EclipseCaseType::INITIAL_PRESSURE_CASE ),
|
|
RimExtractionConfiguration( "EQLNUM",
|
|
RiaDefines::ResultCatType::STATIC_NATIVE,
|
|
RimExtractionConfiguration::EclipseCaseType::DYNAMIC_CASE ),
|
|
|
|
};
|
|
}
|
|
else if ( curveProperty == RiaDefines::CurveProperty::POROSITY || curveProperty == RiaDefines::CurveProperty::POROSITY_UNSCALED ||
|
|
curveProperty == RiaDefines::CurveProperty::PERMEABILITY_X || curveProperty == RiaDefines::CurveProperty::PERMEABILITY_Z )
|
|
{
|
|
QString resultName = eclipseResultVariable( curveProperty );
|
|
return {
|
|
RimExtractionConfiguration( QString( "%1_1" ).arg( resultName ),
|
|
RiaDefines::ResultCatType::INPUT_PROPERTY,
|
|
RimExtractionConfiguration::EclipseCaseType::STATIC_CASE ),
|
|
RimExtractionConfiguration( resultName,
|
|
RiaDefines::ResultCatType::INPUT_PROPERTY,
|
|
RimExtractionConfiguration::EclipseCaseType::STATIC_CASE ),
|
|
RimExtractionConfiguration( resultName,
|
|
RiaDefines::ResultCatType::STATIC_NATIVE,
|
|
RimExtractionConfiguration::EclipseCaseType::DYNAMIC_CASE ),
|
|
};
|
|
}
|
|
|
|
return std::deque<RimExtractionConfiguration>();
|
|
}
|
|
|
|
RimEclipseCase* RimStimPlanModel::eclipseCaseForType( RimExtractionConfiguration::EclipseCaseType caseType ) const
|
|
{
|
|
if ( caseType == RimExtractionConfiguration::EclipseCaseType::STATIC_CASE ) return m_staticEclipseCase;
|
|
if ( caseType == RimExtractionConfiguration::EclipseCaseType::DYNAMIC_CASE ) return m_eclipseCase;
|
|
if ( caseType == RimExtractionConfiguration::EclipseCaseType::INITIAL_PRESSURE_CASE ) return m_initialPressureEclipseCase;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
QString RimStimPlanModel::unitForProperty( RiaDefines::CurveProperty curveProperty ) const
|
|
{
|
|
std::map<RiaDefines::CurveProperty, QString> propertyToUnitMapping;
|
|
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::PERMEABILITY_X] = "mD";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::PERMEABILITY_Z] = "mD";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::YOUNGS_MODULUS] = "MMpsi";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::K_IC] = "<html>psi * √in</html>";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::PROPPANT_EMBEDMENT] = "<html>lb / ft";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::SPURT_LOSS] = "<html>gal / 100ft²</html>";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::FLUID_LOSS_COEFFICIENT] = "<html>ft / √min</html>";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::THERMAL_EXPANSION_COEFFICIENT] = "<html>1 / °C</html>";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::TEMPERATURE] = "<html>°C</html>";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::STRESS] = "Psi";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::INITIAL_STRESS] = "Psi";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::STRESS_GRADIENT] = "Psi / ft";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::PRESSURE] = "Bar";
|
|
propertyToUnitMapping[RiaDefines::CurveProperty::INITIAL_PRESSURE] = "Bar";
|
|
|
|
auto hit = propertyToUnitMapping.find( curveProperty );
|
|
if ( hit != propertyToUnitMapping.end() )
|
|
return hit->second;
|
|
else
|
|
return " ";
|
|
}
|