OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Fix misspelled Allan diagram (#5906)

Browse Source 
Closes #5816
This commit is contained in:
Magne Sjaastad 2020-05-12 12:48:50 +02:00
parent c016c02e40
commit 3d2ac4b573
21 changed files with 153 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ApplicationCode/Application/RiaDefines.cpp
View File

@ -33,7 +33,7 @@ void caf::AppEnum<RiaDefines::ResultCatType>::setUp()
addItem( RiaDefines::ResultCatType::GENERATED, "GENERATED", "Generated" );
addItem( RiaDefines::ResultCatType::INPUT_PROPERTY, "INPUT_PROPERTY", "Input Property" );
addItem( RiaDefines::ResultCatType::FORMATION_NAMES, "FORMATION_NAMES", "Formation Names" );
addItem( RiaDefines::ResultCatType::ALLEN_DIAGRAMS, "ALLEN_DIAGRAMS", "Allen Diagrams" );
addItem( RiaDefines::ResultCatType::ALLAN_DIAGRAMS, "ALLAN_DIAGRAMS", "Allan Diagrams" );
addItem( RiaDefines::ResultCatType::FLOW_DIAGNOSTICS, "FLOW_DIAGNOSTICS", "Flow Diagnostics" );
addItem( RiaDefines::ResultCatType::INJECTION_FLOODING, "INJECTION_FLOODING", "Injection Flooding" );
setDefault( RiaDefines::ResultCatType::DYNAMIC_NATIVE );
@ -386,17 +386,17 @@ QString RiaDefines::completionTypeResultName()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::formationBinaryAllenResultName()
QString RiaDefines::formationBinaryAllanResultName()
{
return "Binary Formation Allen";
return "Binary Formation Allan";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiaDefines::formationAllenResultName()
QString RiaDefines::formationAllanResultName()
{
return "Formation Allen";
return "Formation Allan";
}
//--------------------------------------------------------------------------------------------------

6
ApplicationCode/Application/RiaDefines.h
View File

@ -33,7 +33,7 @@ enum class ResultCatType
GENERATED,
INPUT_PROPERTY,
FORMATION_NAMES,
ALLEN_DIAGRAMS,
ALLAN_DIAGRAMS,
FLOW_DIAGNOSTICS,
INJECTION_FLOODING,
REMOVED,
@ -106,8 +106,8 @@ QString mobilePoreVolumeName();
QString completionTypeResultName();
// Fault results
QString formationBinaryAllenResultName();
QString formationAllenResultName();
QString formationBinaryAllanResultName();
QString formationAllanResultName();
// Mock model text identifiers
QString mockModelBasic();

12
ApplicationCode/GrpcInterface/Python/rips/tests/test_nnc_properties.py
View File

@ -20,9 +20,9 @@ def test_10kSync(rips_instance, initialize_test):
assert("TRAN" == properties[0].name)
assert(NNCProperties_pb2.NNCPropertyType.Value('NNC_STATIC') == properties[0].property_type)
assert("Binary Formation Allen" == properties[1].name)
assert("Binary Formation Allan" == properties[1].name)
assert(NNCProperties_pb2.NNCPropertyType.Value('NNC_GENERATED') == properties[1].property_type)
assert("Formation Allen" == properties[2].name)
assert("Formation Allan" == properties[2].name)
assert(NNCProperties_pb2.NNCPropertyType.Value('NNC_GENERATED') == properties[2].property_type)
nnc_connections = case.nnc_connections()
@ -40,10 +40,10 @@ def test_10kSync(rips_instance, initialize_test):
for t in tran_vals:
assert(isinstance(t, float))
allen_vals = case.nnc_connections_generated_values("Formation Allen", 0)
assert(len(allen_vals) == len(nnc_connections))
allan_vals = case.nnc_connections_generated_values("Formation Allan", 0)
assert(len(allan_vals) == len(nnc_connections))
for a in allen_vals:
for a in allan_vals:
assert(isinstance(a, float))
# Generate some data
@ -81,4 +81,4 @@ def test_invalid_time_steps(rips_instance, initialize_test):
casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
case = rips_instance.project.load_case(path=casePath)
with pytest.raises(grpc.RpcError):
case.nnc_connections_generated_values("Formation Allen", 9999)
case.nnc_connections_generated_values("Formation Allan", 9999)

38
ApplicationCode/ModelVisualization/RivFaultPartMgr.cpp
View File

@ -87,12 +87,12 @@ RivFaultPartMgr::RivFaultPartMgr( const RigGridBase* grid,
m_NNCTextureCoords = new cvf::Vec2fArray;
m_allenNNCGenerator = new RivNNCGeometryGenerator( true,
m_allanNNCGenerator = new RivNNCGeometryGenerator( true,
grid->mainGrid()->nncData(),
grid->mainGrid()->displayModelOffset(),
connIdxes.p() );
m_allenNNCTextureCoords = new cvf::Vec2fArray;
m_allanNNCTextureCoords = new cvf::Vec2fArray;
}
//--------------------------------------------------------------------------------------------------
@ -103,7 +103,7 @@ void RivFaultPartMgr::setCellVisibility( cvf::UByteArray* cellVisibilities )
m_nativeFaultGenerator->setCellVisibility( cellVisibilities );
m_oppositeFaultGenerator->setCellVisibility( cellVisibilities );
m_NNCGenerator->setCellVisibility( cellVisibilities, m_grid.p() );
m_allenNNCGenerator->setCellVisibility( cellVisibilities, m_grid.p() );
m_allanNNCGenerator->setCellVisibility( cellVisibilities, m_grid.p() );
clearFlags();
}
@ -432,7 +432,7 @@ void RivFaultPartMgr::generateNativeNncPartGeometry()
//--------------------------------------------------------------------------------------------------
void RivFaultPartMgr::generateAllNncPartGeometry()
{
cvf::ref<cvf::DrawableGeo> geo = m_allenNNCGenerator->generateSurface();
cvf::ref<cvf::DrawableGeo> geo = m_allanNNCGenerator->generateSurface();
if ( geo.notNull() )
{
geo->computeNormals();
@ -440,12 +440,12 @@ void RivFaultPartMgr::generateAllNncPartGeometry()
geo->setRenderMode( cvf::DrawableGeo::BUFFER_OBJECT );
cvf::ref<cvf::Part> part = new cvf::Part;
part->setName( "Allen NNC in Fault. Grid " + cvf::String( static_cast<int>( m_grid->gridIndex() ) ) );
part->setName( "Allan NNC in Fault. Grid " + cvf::String( static_cast<int>( m_grid->gridIndex() ) ) );
part->setDrawable( geo.p() );
// Set mapping from triangle face index to cell index
cvf::ref<RivSourceInfo> si = new RivSourceInfo( m_rimFault, m_grid->gridIndex() );
si->m_NNCIndices = m_allenNNCGenerator->triangleToNNCIndex().p();
si->m_NNCIndices = m_allanNNCGenerator->triangleToNNCIndex().p();
part->setSourceInfo( si.p() );
part->updateBoundingBox();
@ -455,7 +455,7 @@ void RivFaultPartMgr::generateAllNncPartGeometry()
cvf::ref<cvf::Effect> eff = new cvf::Effect;
part->setEffect( eff.p() );
m_allenNNCFaces = part;
m_allanNNCFaces = part;
updatePartEffect();
}
@ -523,7 +523,7 @@ void RivFaultPartMgr::updatePartEffect()
m_oppositeFaultFaces->setPriority( RivPartPriority::PartType::TransparentFault );
if ( m_NNCFaces.notNull() ) m_NNCFaces->setPriority( RivPartPriority::PartType::TransparentNnc );
if ( m_allenNNCFaces.notNull() ) m_allenNNCFaces->setPriority( RivPartPriority::PartType::TransparentNnc );
if ( m_allanNNCFaces.notNull() ) m_allanNNCFaces->setPriority( RivPartPriority::PartType::TransparentNnc );
if ( m_nativeFaultGridLines.notNull() )
{
@ -734,7 +734,7 @@ void RivFaultPartMgr::appendCompleteNNCFacesToModel( cvf::ModelBasicList* model
generateAllNncPartGeometry();
}
if ( m_allenNNCFaces.notNull() ) model->addPart( m_allenNNCFaces.p() );
if ( m_allanNNCFaces.notNull() ) model->addPart( m_allanNNCFaces.p() );
}
//--------------------------------------------------------------------------------------------------
@ -798,9 +798,9 @@ caf::FaceCulling RivFaultPartMgr::faceCullingMode() const
void RivFaultPartMgr::updateNNCColors( size_t timeStepIndex, RimEclipseCellColors* cellResultColors )
{
bool updateNnc = m_NNCFaces.notNull();
bool updateAllen = m_allenNNCFaces.notNull();
bool updateAllan = m_allanNNCFaces.notNull();
if ( !updateNnc && !updateAllen )
if ( !updateNnc && !updateAllan )
{
return;
}
@ -843,9 +843,9 @@ void RivFaultPartMgr::updateNNCColors( size_t timeStepIndex, RimEclipseCellColor
nativeTimeStepIndex );
}
if ( updateAllen )
if ( updateAllan )
{
m_allenNNCGenerator->textureCoordinates( m_allenNNCTextureCoords.p(),
m_allanNNCGenerator->textureCoordinates( m_allanNNCTextureCoords.p(),
mapper,
resultType,
eclResAddr,
@ -879,12 +879,12 @@ void RivFaultPartMgr::updateNNCColors( size_t timeStepIndex, RimEclipseCellColor
m_NNCFaces->setEffect( nncEffect.p() );
}
if ( updateAllen )
if ( updateAllan )
{
cvf::DrawableGeo* dg = dynamic_cast<cvf::DrawableGeo*>( m_allenNNCFaces->drawable() );
if ( dg ) dg->setTextureCoordArray( m_allenNNCTextureCoords.p() );
cvf::DrawableGeo* dg = dynamic_cast<cvf::DrawableGeo*>( m_allanNNCFaces->drawable() );
if ( dg ) dg->setTextureCoordArray( m_allanNNCTextureCoords.p() );
m_allenNNCFaces->setEffect( nncEffect.p() );
m_allanNNCFaces->setEffect( nncEffect.p() );
}
}
else
@ -916,9 +916,9 @@ void RivFaultPartMgr::updateNNCColors( size_t timeStepIndex, RimEclipseCellColor
m_NNCFaces->setEffect( nncEffect.p() );
}
if ( updateAllen )
if ( updateAllan )
{
m_allenNNCFaces->setEffect( nncEffect.p() );
m_allanNNCFaces->setEffect( nncEffect.p() );
}
}
}

6
ApplicationCode/ModelVisualization/RivFaultPartMgr.h
View File

@ -115,9 +115,9 @@ private:
cvf::ref<cvf::Vec2fArray> m_NNCTextureCoords;
bool m_isAllNncsGenerated;
cvf::ref<RivNNCGeometryGenerator> m_allenNNCGenerator;
cvf::ref<cvf::Part> m_allenNNCFaces;
cvf::ref<cvf::Vec2fArray> m_allenNNCTextureCoords;
cvf::ref<RivNNCGeometryGenerator> m_allanNNCGenerator;
cvf::ref<cvf::Part> m_allanNNCFaces;
cvf::ref<cvf::Vec2fArray> m_allanNNCTextureCoords;
cvf::ref<cvf::Part> m_faultLabelPart;
cvf::ref<cvf::Part> m_faultLabelLinePart;

8
ApplicationCode/ModelVisualization/RivNNCGeometryGenerator.cpp
View File

@ -31,11 +31,11 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivNNCGeometryGenerator::RivNNCGeometryGenerator( bool includeAllen,
RivNNCGeometryGenerator::RivNNCGeometryGenerator( bool includeAllan,
const RigNNCData* nncData,
const cvf::Vec3d& offset,
const cvf::Array<size_t>* nncIndexes )
: m_includeAllenDiagramGeometry( includeAllen )
: m_includeAllanDiagramGeometry( includeAllan )
, m_nncData( nncData )
, m_nncIndexes( nncIndexes )
, m_offset( offset )
@ -90,7 +90,7 @@ void RivNNCGeometryGenerator::computeArrays()
{
size_t conIdx = m_nncIndexes.isNull() ? nIdx : ( *m_nncIndexes )[nIdx];
if ( !m_includeAllenDiagramGeometry && conIdx >= m_nncData->nativeConnectionCount() )
if ( !m_includeAllanDiagramGeometry && conIdx >= m_nncData->nativeConnectionCount() )
{
continue;
}
@ -165,7 +165,7 @@ void RivNNCGeometryGenerator::textureCoordinates( cvf::Vec2fArray*
const std::vector<double>* nncResultVals = nullptr;
if ( resultType == RiaDefines::ResultCatType::STATIC_NATIVE ||
resultType == RiaDefines::ResultCatType::FORMATION_NAMES ||
resultType == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
resultType == RiaDefines::ResultCatType::ALLAN_DIAGRAMS )
{
nncResultVals = m_nncData->staticConnectionScalarResult( resVarAddr );
}

4
ApplicationCode/ModelVisualization/RivNNCGeometryGenerator.h
View File

@ -42,7 +42,7 @@ class RigEclipseResultAddress;
class RivNNCGeometryGenerator : public cvf::Object
{
public:
RivNNCGeometryGenerator( bool includeAllen,
RivNNCGeometryGenerator( bool includeAllan,
const RigNNCData* nncData,
const cvf::Vec3d& offset,
const cvf::Array<size_t>* nncIndexes );
@ -67,7 +67,7 @@ private:
void computeArrays();
private:
bool m_includeAllenDiagramGeometry;
bool m_includeAllanDiagramGeometry;
// Input
cvf::cref<RigNNCData> m_nncData;

2
ApplicationCode/ModelVisualization/RivReservoirFaultsPartMgr.cpp
View File

@ -169,7 +169,7 @@ void RivReservoirFaultsPartMgr::appendPartsToModel( cvf::ModelBasicList* model )
eclipseResultAddress = cellResultColors->eclipseResultAddress();
}
if ( eclipseResultAddress.m_resultCatType == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
if ( eclipseResultAddress.m_resultCatType == RiaDefines::ResultCatType::ALLAN_DIAGRAMS )
{
showCompleteNncGeo = true;
}

27
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

@ -27,7 +27,7 @@
#include "RicfCommandObject.h"
#include "RigActiveCellInfo.h"
#include "RigAllenDiagramData.h"
#include "RigAllanDiagramData.h"
#include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h"
#include "RigEclipseResultInfo.h"
@ -692,7 +692,7 @@ QList<caf::PdmOptionItemInfo>
continue;
}
if ( resType == RiaDefines::ResultCatType::ALLEN_DIAGRAMS && !isSeparateFaultResult )
if ( resType == RiaDefines::ResultCatType::ALLAN_DIAGRAMS && !isSeparateFaultResult )
{
continue;
}
@ -1234,6 +1234,17 @@ void RimEclipseResultDefinition::initAfterRead()
assignFlowSolutionFromCase();
}
if ( m_resultVariable == "Formation Allen" )
{
m_resultVariable = RiaDefines::formationAllanResultName();
m_resultType = RiaDefines::ResultCatType::ALLAN_DIAGRAMS;
}
else if ( m_resultVariable == "Binary Formation Allen" )
{
m_resultVariable = RiaDefines::formationBinaryAllanResultName();
m_resultType = RiaDefines::ResultCatType::ALLAN_DIAGRAMS;
}
m_porosityModelUiField = m_porosityModel;
m_resultTypeUiField = m_resultType;
m_resultVariableUiField = m_resultVariable;
@ -1408,8 +1419,8 @@ bool RimEclipseResultDefinition::hasCategoryResult() const
m_resultVariable() == RIG_FLD_MAX_FRACTION_TRACER_RESNAME )
return true;
if ( this->resultVariable() == RiaDefines::formationAllenResultName() ||
this->resultVariable() == RiaDefines::formationBinaryAllenResultName() )
if ( this->resultVariable() == RiaDefines::formationAllanResultName() ||
this->resultVariable() == RiaDefines::formationBinaryAllanResultName() )
{
return true;
}
@ -1895,9 +1906,9 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
std::vector<QString> fnVector = eclipseCaseData->formationNames();
legendConfigToUpdate->setNamedCategoriesInverse( fnVector );
}
else if ( this->resultType() == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
else if ( this->resultType() == RiaDefines::ResultCatType::ALLAN_DIAGRAMS )
{
if ( this->resultVariable() == RiaDefines::formationAllenResultName() )
if ( this->resultVariable() == RiaDefines::formationAllanResultName() )
{
const std::vector<QString> fnVector = eclipseCaseData->formationNames();
std::vector<int> fnameIdxes;
@ -1911,7 +1922,7 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
formationColorMapper->setInterpolateColors( legendBaseColors );
const std::map<std::pair<int, int>, int>& formationCombToCathegory =
eclipseCaseData->allenDiagramData()->formationCombinationToCategory();
eclipseCaseData->allanDiagramData()->formationCombinationToCategory();
std::vector<std::tuple<QString, int, cvf::Color3ub>> categories;
for ( int frmNameIdx : fnameIdxes )
@ -1941,7 +1952,7 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
legendConfigToUpdate->setCategoryItems( categories );
}
else if ( this->resultVariable() == RiaDefines::formationBinaryAllenResultName() )
else if ( this->resultVariable() == RiaDefines::formationBinaryAllanResultName() )
{
std::vector<std::tuple<QString, int, cvf::Color3ub>> categories;
categories.emplace_back( std::make_tuple( "Same formation", 0, cvf::Color3ub::BROWN ) );

1
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -2250,7 +2250,6 @@ bool RimEclipseView::isUsingFormationNames() const
{
if ( cellResult()->resultType() == RiaDefines::ResultCatType::FORMATION_NAMES ) return true;
if ( faultResultSettings()->customFaultResult()->resultType() == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
return true;
return eclipsePropertyFilterCollection()->isUsingFormationNames();

19
ApplicationCode/ProjectDataModel/RimRegularLegendConfig.cpp
View File

@ -541,6 +541,15 @@ void RimRegularLegendConfig::setAutomaticRanges( double globalMin, double global
//--------------------------------------------------------------------------------------------------
void RimRegularLegendConfig::initAfterRead()
{
if ( resultVariableName == "Binary Formation Allen" )
{
resultVariableName = RiaDefines::formationBinaryAllanResultName();
}
else if ( resultVariableName == "Formation Allen" )
{
resultVariableName = RiaDefines::formationAllanResultName();
}
updateFieldVisibility();
this->updateUiIconFromToggleField();
@ -961,7 +970,7 @@ QList<caf::PdmOptionItemInfo>
if ( rftCurveSet ) hasRftPlotParent = true;
bool isCategoryResult = false;
bool isAllenDiagram = false;
bool isAllanDiagram = false;
{
RimEclipseCellColors* eclCellColors = nullptr;
this->firstAncestorOrThisOfType( eclCellColors );
@ -983,9 +992,9 @@ QList<caf::PdmOptionItemInfo>
isCategoryResult = true;
}
if ( eclCellColors && eclCellColors->resultType() == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
if ( eclCellColors && eclCellColors->resultType() == RiaDefines::ResultCatType::ALLAN_DIAGRAMS )
{
isAllenDiagram = true;
isAllanDiagram = true;
}
}
@ -996,7 +1005,7 @@ QList<caf::PdmOptionItemInfo>
// This is an app enum field, see cafInternalPdmFieldTypeSpecializations.h for the default specialization of
// this type
std::vector<MappingType> mappingTypes;
if ( !isAllenDiagram )
if ( !isAllanDiagram )
{
mappingTypes.push_back( LINEAR_DISCRETE );
@ -1023,7 +1032,7 @@ QList<caf::PdmOptionItemInfo>
// This is an app enum field, see cafInternalPdmFieldTypeSpecializations.h for the default specialization of
// this type
std::vector<ColorRangesType> rangeTypes;
if ( !isAllenDiagram )
if ( !isAllanDiagram )
{
if ( !hasEnsembleCurveSetParent && !hasRftPlotParent )
{

8
ApplicationCode/ReservoirDataModel/CMakeLists_files.cmake
View File

@ -16,7 +16,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RigCombMultResultAccessor.h
${CMAKE_CURRENT_LIST_DIR}/RigResultModifier.h
${CMAKE_CURRENT_LIST_DIR}/RigResultModifierFactory.h
${CMAKE_CURRENT_LIST_DIR}/RigFormationNames.h
${CMAKE_CURRENT_LIST_DIR}/RigAllenDiagramData.h
${CMAKE_CURRENT_LIST_DIR}/RigAllanDiagramData.h
${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResultAddress.h
${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResults.h
${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResultFrames.h
@ -74,7 +74,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RigGridCrossPlotCurveGrouping.h
${CMAKE_CURRENT_LIST_DIR}/RigEclipseCrossPlotDataExtractor.h
${CMAKE_CURRENT_LIST_DIR}/RigEquil.h
${CMAKE_CURRENT_LIST_DIR}/RigWbsParameter.h
${CMAKE_CURRENT_LIST_DIR}/RigEclipseAllenFaultsStatCalc.h
${CMAKE_CURRENT_LIST_DIR}/RigEclipseAllanFaultsStatCalc.h
${CMAKE_CURRENT_LIST_DIR}/RigCellFaceGeometryTools.h
${CMAKE_CURRENT_LIST_DIR}/RigNncConnection.h
${CMAKE_CURRENT_LIST_DIR}/RigWellDiskData.h
@ -97,7 +97,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RigCombTransResultAccessor.cpp
${CMAKE_CURRENT_LIST_DIR}/RigCombMultResultAccessor.cpp
${CMAKE_CURRENT_LIST_DIR}/RigResultModifierFactory.cpp
${CMAKE_CURRENT_LIST_DIR}/RigFormationNames.cpp
${CMAKE_CURRENT_LIST_DIR}/RigAllenDiagramData.cpp
${CMAKE_CURRENT_LIST_DIR}/RigAllanDiagramData.cpp
${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResultAddress.cpp
${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResults.cpp
${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResultFrames.cpp
@ -149,7 +149,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RigCaseCellResultCalculator.cpp
${CMAKE_CURRENT_LIST_DIR}/RigEclipseCrossPlotDataExtractor.cpp
${CMAKE_CURRENT_LIST_DIR}/RigEquil.cpp
${CMAKE_CURRENT_LIST_DIR}/RigWbsParameter.cpp
${CMAKE_CURRENT_LIST_DIR}/RigEclipseAllenFaultsStatCalc.cpp
${CMAKE_CURRENT_LIST_DIR}/RigEclipseAllanFaultsStatCalc.cpp
${CMAKE_CURRENT_LIST_DIR}/RigCellFaceGeometryTools.cpp
${CMAKE_CURRENT_LIST_DIR}/RigNncConnection.cpp
${CMAKE_CURRENT_LIST_DIR}/RigWellDiskData.cpp

6
ApplicationCode/ReservoirDataModel/RigAllenDiagramData.cpp → ApplicationCode/ReservoirDataModel/RigAllanDiagramData.cpp
View File

@ -16,7 +16,7 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RigAllenDiagramData.h"
#include "RigAllanDiagramData.h"
#include "RigCaseCellResultsData.h"
#include "RigFormationNames.h"
@ -25,13 +25,13 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigAllenDiagramData::RigAllenDiagramData()
RigAllanDiagramData::RigAllanDiagramData()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigAllenDiagramData::~RigAllenDiagramData()
RigAllanDiagramData::~RigAllanDiagramData()
{
}

6
ApplicationCode/ReservoirDataModel/RigAllenDiagramData.h → ApplicationCode/ReservoirDataModel/RigAllanDiagramData.h
View File

@ -23,11 +23,11 @@
#include <map>
class RigAllenDiagramData : public cvf::Object
class RigAllanDiagramData : public cvf::Object
{
public:
RigAllenDiagramData();
~RigAllenDiagramData() override;
RigAllanDiagramData();
~RigAllanDiagramData() override;
const std::map<std::pair<int, int>, int>& formationCombinationToCategory()
{

84
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -23,7 +23,7 @@
#include "RiaApplication.h"
#include "RiaLogging.h"
#include "RigAllenDiagramData.h"
#include "RigAllanDiagramData.h"
#include "RigCaseCellResultCalculator.h"
#include "RigEclipseCaseData.h"
#include "RigEclipseMultiPropertyStatCalc.h"
@ -45,7 +45,7 @@
#include <QDateTime>
#include "RigEclipseAllenFaultsStatCalc.h"
#include "RigEclipseAllanFaultsStatCalc.h"
#include <algorithm>
#include <cmath>
@ -63,7 +63,7 @@ RigCaseCellResultsData::RigCaseCellResultsData( RigEclipseCaseData* ow
m_ownerCaseData = ownerCaseData;
m_ownerMainGrid = ownerCaseData->mainGrid();
m_allenDiagramData = new RigAllenDiagramData;
m_allanDiagramData = new RigAllanDiagramData;
}
//--------------------------------------------------------------------------------------------------
@ -454,11 +454,11 @@ size_t RigCaseCellResultsData::findOrCreateScalarResultIndex( const RigEclipseRe
QString( "%1K" ).arg( baseName ) ) );
statisticsCalculator = calc;
}
else if ( resultName == RiaDefines::formationAllenResultName() ||
resultName == RiaDefines::formationBinaryAllenResultName() )
else if ( resultName == RiaDefines::formationAllanResultName() ||
resultName == RiaDefines::formationBinaryAllanResultName() )
{
cvf::ref<RigEclipseAllenFaultsStatCalc> calc =
new RigEclipseAllenFaultsStatCalc( m_ownerMainGrid->nncData(), resVarAddr );
cvf::ref<RigEclipseAllanFaultsStatCalc> calc =
new RigEclipseAllanFaultsStatCalc( m_ownerMainGrid->nncData(), resVarAddr );
statisticsCalculator = calc;
}
else
@ -943,12 +943,12 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
// Fault results
{
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS,
RiaDefines::formationBinaryAllenResultName() ),
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaDefines::formationBinaryAllanResultName() ),
false );
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS,
RiaDefines::formationAllenResultName() ),
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaDefines::formationAllanResultName() ),
false );
}
@ -1276,10 +1276,10 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
{
computeRiTRANSbyAreaComponent( resultName );
}
else if ( resultName == RiaDefines::formationAllenResultName() ||
resultName == RiaDefines::formationBinaryAllenResultName() )
else if ( resultName == RiaDefines::formationAllanResultName() ||
resultName == RiaDefines::formationBinaryAllanResultName() )
{
computeAllenResults( this, m_ownerMainGrid );
computeAllanResults( this, m_ownerMainGrid );
}
}
else if ( type == RiaDefines::ResultCatType::DYNAMIC_NATIVE )
@ -2961,7 +2961,7 @@ void RigCaseCellResultsData::setActiveFormationNames( RigFormationNames* activeF
}
}
computeAllenResults( this, m_ownerMainGrid );
computeAllanResults( this, m_ownerMainGrid );
}
//--------------------------------------------------------------------------------------------------
@ -2975,9 +2975,9 @@ const RigFormationNames* RigCaseCellResultsData::activeFormationNames() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigAllenDiagramData* RigCaseCellResultsData::allenDiagramData()
RigAllanDiagramData* RigCaseCellResultsData::allanDiagramData()
{
return m_allenDiagramData.p();
return m_allanDiagramData.p();
}
//--------------------------------------------------------------------------------------------------
@ -3073,7 +3073,7 @@ RigStatisticsDataCache* RigCaseCellResultsData::statistics( const RigEclipseResu
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigCaseCellResultsData::computeAllenResults( RigCaseCellResultsData* cellResultsData, RigMainGrid* mainGrid )
void RigCaseCellResultsData::computeAllanResults( RigCaseCellResultsData* cellResultsData, RigMainGrid* mainGrid )
{
CVF_ASSERT( mainGrid );
CVF_ASSERT( cellResultsData );
@ -3084,38 +3084,38 @@ void RigCaseCellResultsData::computeAllenResults( RigCaseCellResultsData* cellRe
if ( hasFormationData )
{
auto fnAllenResultResAddr =
RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS, RiaDefines::formationAllenResultName() );
auto fnBinAllenResAddr = RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS,
RiaDefines::formationBinaryAllenResultName() );
auto fnAllanResultResAddr =
RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS, RiaDefines::formationAllanResultName() );
auto fnBinAllanResAddr = RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaDefines::formationBinaryAllanResultName() );
// Create and retreive nnc result arrays
std::vector<double>& fnAllenNncResults =
mainGrid->nncData()->makeStaticConnectionScalarResult( RiaDefines::formationAllenResultName() );
std::vector<double>& fnBinAllenNncResults =
mainGrid->nncData()->makeStaticConnectionScalarResult( RiaDefines::formationBinaryAllenResultName() );
std::vector<double>& fnAllanNncResults =
mainGrid->nncData()->makeStaticConnectionScalarResult( RiaDefines::formationAllanResultName() );
std::vector<double>& fnBinAllanNncResults =
mainGrid->nncData()->makeStaticConnectionScalarResult( RiaDefines::formationBinaryAllanResultName() );
// Associate them with eclipse result address
mainGrid->nncData()->setEclResultAddress( RiaDefines::formationAllenResultName(), fnAllenResultResAddr );
mainGrid->nncData()->setEclResultAddress( RiaDefines::formationBinaryAllenResultName(), fnBinAllenResAddr );
mainGrid->nncData()->setEclResultAddress( RiaDefines::formationAllanResultName(), fnAllanResultResAddr );
mainGrid->nncData()->setEclResultAddress( RiaDefines::formationBinaryAllanResultName(), fnBinAllanResAddr );
const std::vector<double>& fnData = cellResultsData->cellScalarResults( fnNamesResAddr, 0 );
// Add a result entry for the special allen grid data (used only for the grid cells without nnc coverage)
// Add a result entry for the special Allan grid data (used only for the grid cells without nnc coverage)
cellResultsData->addStaticScalarResult( RiaDefines::ResultCatType::ALLEN_DIAGRAMS,
RiaDefines::formationAllenResultName(),
cellResultsData->addStaticScalarResult( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaDefines::formationAllanResultName(),
false,
fnData.size() );
cellResultsData->addStaticScalarResult( RiaDefines::ResultCatType::ALLEN_DIAGRAMS,
RiaDefines::formationBinaryAllenResultName(),
cellResultsData->addStaticScalarResult( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaDefines::formationBinaryAllanResultName(),
false,
fnData.size() );
std::vector<double>* alData = cellResultsData->modifiableCellScalarResult( fnAllenResultResAddr, 0 );
std::vector<double>* binAlData = cellResultsData->modifiableCellScalarResult( fnBinAllenResAddr, 0 );
std::vector<double>* alData = cellResultsData->modifiableCellScalarResult( fnAllanResultResAddr, 0 );
std::vector<double>* binAlData = cellResultsData->modifiableCellScalarResult( fnBinAllanResAddr, 0 );
( *alData ) = fnData;
@ -3164,18 +3164,18 @@ void RigCaseCellResultsData::computeAllenResults( RigCaseCellResultsData* cellRe
formationCombinationToCategory[formationCombination] = category;
}
fnBinAllenNncResults[i] = 1.0;
fnBinAllanNncResults[i] = 1.0;
}
else
{
category = formation1;
fnBinAllenNncResults[i] = 0.0;
fnBinAllanNncResults[i] = 0.0;
}
fnAllenNncResults[i] = category;
fnAllanNncResults[i] = category;
}
cellResultsData->allenDiagramData()->setFormationCombinationToCategorymap( formationCombinationToCategory );
cellResultsData->allanDiagramData()->setFormationCombinationToCategorymap( formationCombinationToCategory );
}
else
{
@ -3199,9 +3199,9 @@ void RigCaseCellResultsData::computeAllenResults( RigCaseCellResultsData* cellRe
binaryValue = 1.0;
}
fnAllenNncResults[i] = k1;
allAllenFormationResults[i] = k1;
fnBinAllenNncResults[i] = binaryValue;
fnAllanNncResults[i] = k1;
allAllanFormationResults[i] = k1;
fnBinAllanNncResults[i] = binaryValue;
}
#endif
}

8
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.h
View File

@ -41,7 +41,7 @@ class RigStatisticsDataCache;
class RigEclipseTimeStepInfo;
class RigEclipseCaseData;
class RigFormationNames;
class RigAllenDiagramData;
class RigAllanDiagramData;
class RimEclipseCase;
@ -60,7 +60,7 @@ public:
void setHdf5Filename( const QString& hdf5SourSimFilename );
void setActiveFormationNames( RigFormationNames* activeFormationNames );
const RigFormationNames* activeFormationNames() const;
RigAllenDiagramData* allenDiagramData();
RigAllanDiagramData* allanDiagramData();
void setMainGrid( RigMainGrid* ownerGrid );
void setActiveCellInfo( RigActiveCellInfo* activeCellInfo );
@ -191,12 +191,12 @@ private:
RigStatisticsDataCache* statistics( const RigEclipseResultAddress& resVarAddr );
static void computeAllenResults( RigCaseCellResultsData* cellResultsData, RigMainGrid* mainGrid );
static void computeAllanResults( RigCaseCellResultsData* cellResultsData, RigMainGrid* mainGrid );
private:
cvf::ref<RifReaderInterface> m_readerInterface;
cvf::cref<RigFormationNames> m_activeFormationNamesData;
cvf::ref<RigAllenDiagramData> m_allenDiagramData;
cvf::ref<RigAllanDiagramData> m_allanDiagramData;
std::vector<std::vector<std::vector<double>>> m_cellScalarResults; ///< Scalar results on the complete reservoir for
///< each Result index (ResultVariable) and timestep

18
ApplicationCode/ReservoirDataModel/RigEclipseAllenFaultsStatCalc.cpp → ApplicationCode/ReservoirDataModel/RigEclipseAllanFaultsStatCalc.cpp
View File

@ -17,7 +17,7 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RigEclipseAllenFaultsStatCalc.h"
#include "RigEclipseAllanFaultsStatCalc.h"
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
@ -30,7 +30,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigEclipseAllenFaultsStatCalc::RigEclipseAllenFaultsStatCalc( RigNNCData* cellResultsData,
RigEclipseAllanFaultsStatCalc::RigEclipseAllanFaultsStatCalc( RigNNCData* cellResultsData,
const RigEclipseResultAddress& scalarResultIndex )
: m_caseData( cellResultsData )
, m_resultAddress( scalarResultIndex )
@ -40,7 +40,7 @@ RigEclipseAllenFaultsStatCalc::RigEclipseAllenFaultsStatCalc( RigNNCData*
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseAllenFaultsStatCalc::minMaxCellScalarValues( size_t timeStepIndex, double& min, double& max )
void RigEclipseAllanFaultsStatCalc::minMaxCellScalarValues( size_t timeStepIndex, double& min, double& max )
{
MinMaxAccumulator acc( min, max );
traverseCells( acc, timeStepIndex );
@ -51,7 +51,7 @@ void RigEclipseAllenFaultsStatCalc::minMaxCellScalarValues( size_t timeStepIndex
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseAllenFaultsStatCalc::posNegClosestToZero( size_t timeStepIndex, double& pos, double& neg )
void RigEclipseAllanFaultsStatCalc::posNegClosestToZero( size_t timeStepIndex, double& pos, double& neg )
{
PosNegAccumulator acc( pos, neg );
traverseCells( acc, timeStepIndex );
@ -62,7 +62,7 @@ void RigEclipseAllenFaultsStatCalc::posNegClosestToZero( size_t timeStepIndex, d
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseAllenFaultsStatCalc::valueSumAndSampleCount( size_t timeStepIndex, double& valueSum, size_t& sampleCount )
void RigEclipseAllanFaultsStatCalc::valueSumAndSampleCount( size_t timeStepIndex, double& valueSum, size_t& sampleCount )
{
SumCountAccumulator acc( valueSum, sampleCount );
traverseCells( acc, timeStepIndex );
@ -73,7 +73,7 @@ void RigEclipseAllenFaultsStatCalc::valueSumAndSampleCount( size_t timeStepIndex
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseAllenFaultsStatCalc::addDataToHistogramCalculator( size_t timeStepIndex,
void RigEclipseAllanFaultsStatCalc::addDataToHistogramCalculator( size_t timeStepIndex,
RigHistogramCalculator& histogramCalculator )
{
traverseCells( histogramCalculator, timeStepIndex );
@ -82,7 +82,7 @@ void RigEclipseAllenFaultsStatCalc::addDataToHistogramCalculator( size_t
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseAllenFaultsStatCalc::uniqueValues( size_t timeStepIndex, std::set<int>& values )
void RigEclipseAllanFaultsStatCalc::uniqueValues( size_t timeStepIndex, std::set<int>& values )
{
UniqueValueAccumulator acc;
traverseCells( acc, timeStepIndex );
@ -92,7 +92,7 @@ void RigEclipseAllenFaultsStatCalc::uniqueValues( size_t timeStepIndex, std::set
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t RigEclipseAllenFaultsStatCalc::timeStepCount()
size_t RigEclipseAllanFaultsStatCalc::timeStepCount()
{
return (size_t)1;
}
@ -100,6 +100,6 @@ size_t RigEclipseAllenFaultsStatCalc::timeStepCount()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigEclipseAllenFaultsStatCalc::mobileVolumeWeightedMean( size_t timeStepIndex, double& result )
void RigEclipseAllanFaultsStatCalc::mobileVolumeWeightedMean( size_t timeStepIndex, double& result )
{
}

4
ApplicationCode/ReservoirDataModel/RigEclipseAllenFaultsStatCalc.h → ApplicationCode/ReservoirDataModel/RigEclipseAllanFaultsStatCalc.h
View File

@ -30,10 +30,10 @@
#include "cvfArray.h"
class RigEclipseAllenFaultsStatCalc : public RigStatisticsCalculator
class RigEclipseAllanFaultsStatCalc : public RigStatisticsCalculator
{
public:
RigEclipseAllenFaultsStatCalc( RigNNCData* cellResultsData, const RigEclipseResultAddress& scalarResultIndex );
RigEclipseAllanFaultsStatCalc( RigNNCData* cellResultsData, const RigEclipseResultAddress& scalarResultIndex );
void minMaxCellScalarValues( size_t timeStepIndex, double& min, double& max ) override;
void posNegClosestToZero( size_t timeStepIndex, double& pos, double& neg ) override;

4
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.cpp
View File

@ -726,9 +726,9 @@ const std::vector<QString> RigEclipseCaseData::formationNames() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigAllenDiagramData* RigEclipseCaseData::allenDiagramData()
RigAllanDiagramData* RigEclipseCaseData::allanDiagramData()
{
return m_matrixModelResults->allenDiagramData();
return m_matrixModelResults->allanDiagramData();
}
//--------------------------------------------------------------------------------------------------

4
ApplicationCode/ReservoirDataModel/RigEclipseCaseData.h
View File

@ -47,7 +47,7 @@ class RigWellPath;
class RimEclipseCase;
class RigVirtualPerforationTransmissibilities;
class RigEquil;
class RigAllenDiagramData;
class RigAllanDiagramData;
struct RigWellResultPoint;
@ -89,7 +89,7 @@ public:
void setActiveFormationNames( RigFormationNames* activeFormationNames );
const RigFormationNames* activeFormationNames() const;
const std::vector<QString> formationNames() const;
RigAllenDiagramData* allenDiagramData();
RigAllanDiagramData* allanDiagramData();
void setSimWellData( const cvf::Collection<RigSimWellData>& data );
const cvf::Collection<RigSimWellData>& wellResults() const { return m_simWellData; }

12
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

@ -40,7 +40,7 @@
#include "RivExtrudedCurveIntersectionPartMgr.h"
#include "RigAllenDiagramData.h"
#include "RigAllanDiagramData.h"
#include "RimIntersectionResultDefinition.h"
#include "cafDisplayCoordTransform.h"
@ -323,7 +323,7 @@ QString RiuResultTextBuilder::faultResultDetails()
if ( m_viewWithFaultsSettings && m_viewWithFaultsSettings->faultResultSettings()->hasValidCustomResult() )
{
if ( m_viewWithFaultsSettings->faultResultSettings()->customFaultResult()->resultType() !=
RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
RiaDefines::ResultCatType::ALLAN_DIAGRAMS )
{
text += "Fault result data:\n";
this->appendTextFromResultColors( eclipseCaseData,
@ -478,16 +478,16 @@ QString RiuResultTextBuilder::nncResultText()
text = QString( "%1 : %2" ).arg( resultVar ).arg( scalarValue );
}
if ( resultType == RiaDefines::ResultCatType::ALLEN_DIAGRAMS )
if ( resultType == RiaDefines::ResultCatType::ALLAN_DIAGRAMS )
{
nncValues = nncData->staticConnectionScalarResult( eclipseResultAddress );
QString resultValueText;
if ( m_viewWithFaultsSettings->currentFaultResultColors()->resultVariable() ==
RiaDefines::formationAllenResultName() )
RiaDefines::formationAllanResultName() )
{
std::pair<int, int> fmIndexPair =
eclipseCase->allenDiagramData()->formationIndexCombinationFromCategory(
eclipseCase->allanDiagramData()->formationIndexCombinationFromCategory(
( *nncValues )[m_nncIndex] );
std::vector<QString> fmNames = eclipseCase->formationNames();
@ -503,7 +503,7 @@ QString RiuResultTextBuilder::nncResultText()
// clang-format on
}
else if ( m_viewWithFaultsSettings->currentFaultResultColors()->resultVariable() ==
RiaDefines::formationBinaryAllenResultName() )
RiaDefines::formationBinaryAllanResultName() )
{
resultValueText = ( *nncValues )[m_nncIndex] == 0 ? "Same formation" : "Different formation";
}