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::GENERATED, "GENERATED", "Generated" );
addItem( RiaDefines::ResultCatType::INPUT_PROPERTY, "INPUT_PROPERTY", "Input Property" ); addItem( RiaDefines::ResultCatType::INPUT_PROPERTY, "INPUT_PROPERTY", "Input Property" );
addItem( RiaDefines::ResultCatType::FORMATION_NAMES, "FORMATION_NAMES", "Formation Names" ); 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::FLOW_DIAGNOSTICS, "FLOW_DIAGNOSTICS", "Flow Diagnostics" );
addItem( RiaDefines::ResultCatType::INJECTION_FLOODING, "INJECTION_FLOODING", "Injection Flooding" ); addItem( RiaDefines::ResultCatType::INJECTION_FLOODING, "INJECTION_FLOODING", "Injection Flooding" );
setDefault( RiaDefines::ResultCatType::DYNAMIC_NATIVE ); 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, GENERATED,
INPUT_PROPERTY, INPUT_PROPERTY,
FORMATION_NAMES, FORMATION_NAMES,
ALLEN_DIAGRAMS, ALLAN_DIAGRAMS,
FLOW_DIAGNOSTICS, FLOW_DIAGNOSTICS,
INJECTION_FLOODING, INJECTION_FLOODING,
REMOVED, REMOVED,
@ -106,8 +106,8 @@ QString mobilePoreVolumeName();
QString completionTypeResultName(); QString completionTypeResultName();
// Fault results // Fault results
QString formationBinaryAllenResultName(); QString formationBinaryAllanResultName();
QString formationAllenResultName(); QString formationAllanResultName();
// Mock model text identifiers // Mock model text identifiers
QString mockModelBasic(); 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("TRAN" == properties[0].name)
assert(NNCProperties_pb2.NNCPropertyType.Value('NNC_STATIC') == properties[0].property_type) 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(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) assert(NNCProperties_pb2.NNCPropertyType.Value('NNC_GENERATED') == properties[2].property_type)
nnc_connections = case.nnc_connections() nnc_connections = case.nnc_connections()
@ -40,10 +40,10 @@ def test_10kSync(rips_instance, initialize_test):
for t in tran_vals: for t in tran_vals:
assert(isinstance(t, float)) assert(isinstance(t, float))
allen_vals = case.nnc_connections_generated_values("Formation Allen", 0) allan_vals = case.nnc_connections_generated_values("Formation Allan", 0)
assert(len(allen_vals) == len(nnc_connections)) assert(len(allan_vals) == len(nnc_connections))
for a in allen_vals: for a in allan_vals:
assert(isinstance(a, float)) assert(isinstance(a, float))
# Generate some data # 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" casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
case = rips_instance.project.load_case(path=casePath) case = rips_instance.project.load_case(path=casePath)
with pytest.raises(grpc.RpcError): 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_NNCTextureCoords = new cvf::Vec2fArray;
m_allenNNCGenerator = new RivNNCGeometryGenerator( true, m_allanNNCGenerator = new RivNNCGeometryGenerator( true,
grid->mainGrid()->nncData(), grid->mainGrid()->nncData(),
grid->mainGrid()->displayModelOffset(), grid->mainGrid()->displayModelOffset(),
connIdxes.p() ); 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_nativeFaultGenerator->setCellVisibility( cellVisibilities );
m_oppositeFaultGenerator->setCellVisibility( cellVisibilities ); m_oppositeFaultGenerator->setCellVisibility( cellVisibilities );
m_NNCGenerator->setCellVisibility( cellVisibilities, m_grid.p() ); m_NNCGenerator->setCellVisibility( cellVisibilities, m_grid.p() );
m_allenNNCGenerator->setCellVisibility( cellVisibilities, m_grid.p() ); m_allanNNCGenerator->setCellVisibility( cellVisibilities, m_grid.p() );
clearFlags(); clearFlags();
} }
@ -432,7 +432,7 @@ void RivFaultPartMgr::generateNativeNncPartGeometry()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RivFaultPartMgr::generateAllNncPartGeometry() void RivFaultPartMgr::generateAllNncPartGeometry()
{ {
cvf::ref<cvf::DrawableGeo> geo = m_allenNNCGenerator->generateSurface(); cvf::ref<cvf::DrawableGeo> geo = m_allanNNCGenerator->generateSurface();
if ( geo.notNull() ) if ( geo.notNull() )
{ {
geo->computeNormals(); geo->computeNormals();
@ -440,12 +440,12 @@ void RivFaultPartMgr::generateAllNncPartGeometry()
geo->setRenderMode( cvf::DrawableGeo::BUFFER_OBJECT ); geo->setRenderMode( cvf::DrawableGeo::BUFFER_OBJECT );
cvf::ref<cvf::Part> part = new cvf::Part; 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() ); part->setDrawable( geo.p() );
// Set mapping from triangle face index to cell index // Set mapping from triangle face index to cell index
cvf::ref<RivSourceInfo> si = new RivSourceInfo( m_rimFault, m_grid->gridIndex() ); 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->setSourceInfo( si.p() );
part->updateBoundingBox(); part->updateBoundingBox();
@ -455,7 +455,7 @@ void RivFaultPartMgr::generateAllNncPartGeometry()
cvf::ref<cvf::Effect> eff = new cvf::Effect; cvf::ref<cvf::Effect> eff = new cvf::Effect;
part->setEffect( eff.p() ); part->setEffect( eff.p() );
m_allenNNCFaces = part; m_allanNNCFaces = part;
updatePartEffect(); updatePartEffect();
} }
@ -523,7 +523,7 @@ void RivFaultPartMgr::updatePartEffect()
m_oppositeFaultFaces->setPriority( RivPartPriority::PartType::TransparentFault ); m_oppositeFaultFaces->setPriority( RivPartPriority::PartType::TransparentFault );
if ( m_NNCFaces.notNull() ) m_NNCFaces->setPriority( RivPartPriority::PartType::TransparentNnc ); 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() ) if ( m_nativeFaultGridLines.notNull() )
{ {
@ -734,7 +734,7 @@ void RivFaultPartMgr::appendCompleteNNCFacesToModel( cvf::ModelBasicList* model
generateAllNncPartGeometry(); 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 ) void RivFaultPartMgr::updateNNCColors( size_t timeStepIndex, RimEclipseCellColors* cellResultColors )
{ {
bool updateNnc = m_NNCFaces.notNull(); bool updateNnc = m_NNCFaces.notNull();
bool updateAllen = m_allenNNCFaces.notNull(); bool updateAllan = m_allanNNCFaces.notNull();
if ( !updateNnc && !updateAllen ) if ( !updateNnc && !updateAllan )
{ {
return; return;
} }
@ -843,9 +843,9 @@ void RivFaultPartMgr::updateNNCColors( size_t timeStepIndex, RimEclipseCellColor
nativeTimeStepIndex ); nativeTimeStepIndex );
} }
if ( updateAllen ) if ( updateAllan )
{ {
m_allenNNCGenerator->textureCoordinates( m_allenNNCTextureCoords.p(), m_allanNNCGenerator->textureCoordinates( m_allanNNCTextureCoords.p(),
mapper, mapper,
resultType, resultType,
eclResAddr, eclResAddr,
@ -879,12 +879,12 @@ void RivFaultPartMgr::updateNNCColors( size_t timeStepIndex, RimEclipseCellColor
m_NNCFaces->setEffect( nncEffect.p() ); m_NNCFaces->setEffect( nncEffect.p() );
} }
if ( updateAllen ) if ( updateAllan )
{ {
cvf::DrawableGeo* dg = dynamic_cast<cvf::DrawableGeo*>( m_allenNNCFaces->drawable() ); cvf::DrawableGeo* dg = dynamic_cast<cvf::DrawableGeo*>( m_allanNNCFaces->drawable() );
if ( dg ) dg->setTextureCoordArray( m_allenNNCTextureCoords.p() ); if ( dg ) dg->setTextureCoordArray( m_allanNNCTextureCoords.p() );
m_allenNNCFaces->setEffect( nncEffect.p() ); m_allanNNCFaces->setEffect( nncEffect.p() );
} }
} }
else else
@ -916,9 +916,9 @@ void RivFaultPartMgr::updateNNCColors( size_t timeStepIndex, RimEclipseCellColor
m_NNCFaces->setEffect( nncEffect.p() ); 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; cvf::ref<cvf::Vec2fArray> m_NNCTextureCoords;
bool m_isAllNncsGenerated; bool m_isAllNncsGenerated;
cvf::ref<RivNNCGeometryGenerator> m_allenNNCGenerator; cvf::ref<RivNNCGeometryGenerator> m_allanNNCGenerator;
cvf::ref<cvf::Part> m_allenNNCFaces; cvf::ref<cvf::Part> m_allanNNCFaces;
cvf::ref<cvf::Vec2fArray> m_allenNNCTextureCoords; cvf::ref<cvf::Vec2fArray> m_allanNNCTextureCoords;
cvf::ref<cvf::Part> m_faultLabelPart; cvf::ref<cvf::Part> m_faultLabelPart;
cvf::ref<cvf::Part> m_faultLabelLinePart; 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 RigNNCData* nncData,
const cvf::Vec3d& offset, const cvf::Vec3d& offset,
const cvf::Array<size_t>* nncIndexes ) const cvf::Array<size_t>* nncIndexes )
: m_includeAllenDiagramGeometry( includeAllen ) : m_includeAllanDiagramGeometry( includeAllan )
, m_nncData( nncData ) , m_nncData( nncData )
, m_nncIndexes( nncIndexes ) , m_nncIndexes( nncIndexes )
, m_offset( offset ) , m_offset( offset )
@ -90,7 +90,7 @@ void RivNNCGeometryGenerator::computeArrays()
{ {
size_t conIdx = m_nncIndexes.isNull() ? nIdx : ( *m_nncIndexes )[nIdx]; 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; continue;
} }
@ -165,7 +165,7 @@ void RivNNCGeometryGenerator::textureCoordinates( cvf::Vec2fArray*
const std::vector<double>* nncResultVals = nullptr; const std::vector<double>* nncResultVals = nullptr;
if ( resultType == RiaDefines::ResultCatType::STATIC_NATIVE || if ( resultType == RiaDefines::ResultCatType::STATIC_NATIVE ||
resultType == RiaDefines::ResultCatType::FORMATION_NAMES || resultType == RiaDefines::ResultCatType::FORMATION_NAMES ||
resultType == RiaDefines::ResultCatType::ALLEN_DIAGRAMS ) resultType == RiaDefines::ResultCatType::ALLAN_DIAGRAMS )
{ {
nncResultVals = m_nncData->staticConnectionScalarResult( resVarAddr ); nncResultVals = m_nncData->staticConnectionScalarResult( resVarAddr );
} }

4
ApplicationCode/ModelVisualization/RivNNCGeometryGenerator.h
View File

@ -42,7 +42,7 @@ class RigEclipseResultAddress;
class RivNNCGeometryGenerator : public cvf::Object class RivNNCGeometryGenerator : public cvf::Object
{ {
public: public:
RivNNCGeometryGenerator( bool includeAllen, RivNNCGeometryGenerator( bool includeAllan,
const RigNNCData* nncData, const RigNNCData* nncData,
const cvf::Vec3d& offset, const cvf::Vec3d& offset,
const cvf::Array<size_t>* nncIndexes ); const cvf::Array<size_t>* nncIndexes );
@ -67,7 +67,7 @@ private:
void computeArrays(); void computeArrays();
private: private:
bool m_includeAllenDiagramGeometry; bool m_includeAllanDiagramGeometry;
// Input // Input
cvf::cref<RigNNCData> m_nncData; 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(); eclipseResultAddress = cellResultColors->eclipseResultAddress();
} }
if ( eclipseResultAddress.m_resultCatType == RiaDefines::ResultCatType::ALLEN_DIAGRAMS ) if ( eclipseResultAddress.m_resultCatType == RiaDefines::ResultCatType::ALLAN_DIAGRAMS )
{ {
showCompleteNncGeo = true; showCompleteNncGeo = true;
} }

27
ApplicationCode/ProjectDataModel/RimEclipseResultDefinition.cpp
View File

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

19
ApplicationCode/ProjectDataModel/RimRegularLegendConfig.cpp
View File

@ -541,6 +541,15 @@ void RimRegularLegendConfig::setAutomaticRanges( double globalMin, double global
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimRegularLegendConfig::initAfterRead() void RimRegularLegendConfig::initAfterRead()
{ {
if ( resultVariableName == "Binary Formation Allen" )
{
resultVariableName = RiaDefines::formationBinaryAllanResultName();
}
else if ( resultVariableName == "Formation Allen" )
{
resultVariableName = RiaDefines::formationAllanResultName();
}
updateFieldVisibility(); updateFieldVisibility();
this->updateUiIconFromToggleField(); this->updateUiIconFromToggleField();
@ -961,7 +970,7 @@ QList<caf::PdmOptionItemInfo>
if ( rftCurveSet ) hasRftPlotParent = true; if ( rftCurveSet ) hasRftPlotParent = true;
bool isCategoryResult = false; bool isCategoryResult = false;
bool isAllenDiagram = false; bool isAllanDiagram = false;
{ {
RimEclipseCellColors* eclCellColors = nullptr; RimEclipseCellColors* eclCellColors = nullptr;
this->firstAncestorOrThisOfType( eclCellColors ); this->firstAncestorOrThisOfType( eclCellColors );
@ -983,9 +992,9 @@ QList<caf::PdmOptionItemInfo>
isCategoryResult = true; 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 is an app enum field, see cafInternalPdmFieldTypeSpecializations.h for the default specialization of
// this type // this type
std::vector<MappingType> mappingTypes; std::vector<MappingType> mappingTypes;
if ( !isAllenDiagram ) if ( !isAllanDiagram )
{ {
mappingTypes.push_back( LINEAR_DISCRETE ); 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 is an app enum field, see cafInternalPdmFieldTypeSpecializations.h for the default specialization of
// this type // this type
std::vector<ColorRangesType> rangeTypes; std::vector<ColorRangesType> rangeTypes;
if ( !isAllenDiagram ) if ( !isAllanDiagram )
{ {
if ( !hasEnsembleCurveSetParent && !hasRftPlotParent ) 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}/RigResultModifier.h
${CMAKE_CURRENT_LIST_DIR}/RigResultModifierFactory.h ${CMAKE_CURRENT_LIST_DIR}/RigResultModifierFactory.h
${CMAKE_CURRENT_LIST_DIR}/RigFormationNames.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}/RigFlowDiagResultAddress.h
${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResults.h ${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResults.h
${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResultFrames.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}/RigEclipseCrossPlotDataExtractor.h
${CMAKE_CURRENT_LIST_DIR}/RigEquil.h ${CMAKE_CURRENT_LIST_DIR}/RigEquil.h
${CMAKE_CURRENT_LIST_DIR}/RigWbsParameter.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}/RigCellFaceGeometryTools.h
${CMAKE_CURRENT_LIST_DIR}/RigNncConnection.h ${CMAKE_CURRENT_LIST_DIR}/RigNncConnection.h
${CMAKE_CURRENT_LIST_DIR}/RigWellDiskData.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}/RigCombMultResultAccessor.cpp
${CMAKE_CURRENT_LIST_DIR}/RigResultModifierFactory.cpp ${CMAKE_CURRENT_LIST_DIR}/RigResultModifierFactory.cpp
${CMAKE_CURRENT_LIST_DIR}/RigFormationNames.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}/RigFlowDiagResultAddress.cpp
${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResults.cpp ${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResults.cpp
${CMAKE_CURRENT_LIST_DIR}/RigFlowDiagResultFrames.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}/RigEclipseCrossPlotDataExtractor.cpp
${CMAKE_CURRENT_LIST_DIR}/RigEquil.cpp ${CMAKE_CURRENT_LIST_DIR}/RigEquil.cpp
${CMAKE_CURRENT_LIST_DIR}/RigWbsParameter.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}/RigCellFaceGeometryTools.cpp
${CMAKE_CURRENT_LIST_DIR}/RigNncConnection.cpp ${CMAKE_CURRENT_LIST_DIR}/RigNncConnection.cpp
${CMAKE_CURRENT_LIST_DIR}/RigWellDiskData.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 "RigCaseCellResultsData.h"
#include "RigFormationNames.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> #include <map>
class RigAllenDiagramData : public cvf::Object class RigAllanDiagramData : public cvf::Object
{ {
public: public:
RigAllenDiagramData(); RigAllanDiagramData();
~RigAllenDiagramData() override; ~RigAllanDiagramData() override;
const std::map<std::pair<int, int>, int>& formationCombinationToCategory() const std::map<std::pair<int, int>, int>& formationCombinationToCategory()
{ {

84
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -23,7 +23,7 @@
#include "RiaApplication.h" #include "RiaApplication.h"
#include "RiaLogging.h" #include "RiaLogging.h"
#include "RigAllenDiagramData.h" #include "RigAllanDiagramData.h"
#include "RigCaseCellResultCalculator.h" #include "RigCaseCellResultCalculator.h"
#include "RigEclipseCaseData.h" #include "RigEclipseCaseData.h"
#include "RigEclipseMultiPropertyStatCalc.h" #include "RigEclipseMultiPropertyStatCalc.h"
@ -45,7 +45,7 @@
#include <QDateTime> #include <QDateTime>
#include "RigEclipseAllenFaultsStatCalc.h" #include "RigEclipseAllanFaultsStatCalc.h"
#include <algorithm> #include <algorithm>
#include <cmath> #include <cmath>
@ -63,7 +63,7 @@ RigCaseCellResultsData::RigCaseCellResultsData( RigEclipseCaseData* ow
m_ownerCaseData = ownerCaseData; m_ownerCaseData = ownerCaseData;
m_ownerMainGrid = ownerCaseData->mainGrid(); 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 ) ) ); QString( "%1K" ).arg( baseName ) ) );
statisticsCalculator = calc; statisticsCalculator = calc;
} }
else if ( resultName == RiaDefines::formationAllenResultName() || else if ( resultName == RiaDefines::formationAllanResultName() ||
resultName == RiaDefines::formationBinaryAllenResultName() ) resultName == RiaDefines::formationBinaryAllanResultName() )
{ {
cvf::ref<RigEclipseAllenFaultsStatCalc> calc = cvf::ref<RigEclipseAllanFaultsStatCalc> calc =
new RigEclipseAllenFaultsStatCalc( m_ownerMainGrid->nncData(), resVarAddr ); new RigEclipseAllanFaultsStatCalc( m_ownerMainGrid->nncData(), resVarAddr );
statisticsCalculator = calc; statisticsCalculator = calc;
} }
else else
@ -943,12 +943,12 @@ void RigCaseCellResultsData::createPlaceholderResultEntries()
// Fault results // Fault results
{ {
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaDefines::formationBinaryAllenResultName() ), RiaDefines::formationBinaryAllanResultName() ),
false ); false );
findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS, findOrCreateScalarResultIndex( RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaDefines::formationAllenResultName() ), RiaDefines::formationAllanResultName() ),
false ); false );
} }
@ -1276,10 +1276,10 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
{ {
computeRiTRANSbyAreaComponent( resultName ); computeRiTRANSbyAreaComponent( resultName );
} }
else if ( resultName == RiaDefines::formationAllenResultName() || else if ( resultName == RiaDefines::formationAllanResultName() ||
resultName == RiaDefines::formationBinaryAllenResultName() ) resultName == RiaDefines::formationBinaryAllanResultName() )
{ {
computeAllenResults( this, m_ownerMainGrid ); computeAllanResults( this, m_ownerMainGrid );
} }
} }
else if ( type == RiaDefines::ResultCatType::DYNAMIC_NATIVE ) 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( mainGrid );
CVF_ASSERT( cellResultsData ); CVF_ASSERT( cellResultsData );
@ -3084,38 +3084,38 @@ void RigCaseCellResultsData::computeAllenResults( RigCaseCellResultsData* cellRe
if ( hasFormationData ) if ( hasFormationData )
{ {
auto fnAllenResultResAddr = auto fnAllanResultResAddr =
RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS, RiaDefines::formationAllenResultName() ); RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS, RiaDefines::formationAllanResultName() );
auto fnBinAllenResAddr = RigEclipseResultAddress( RiaDefines::ResultCatType::ALLEN_DIAGRAMS, auto fnBinAllanResAddr = RigEclipseResultAddress( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaDefines::formationBinaryAllenResultName() ); RiaDefines::formationBinaryAllanResultName() );
// Create and retreive nnc result arrays // Create and retreive nnc result arrays
std::vector<double>& fnAllenNncResults = std::vector<double>& fnAllanNncResults =
mainGrid->nncData()->makeStaticConnectionScalarResult( RiaDefines::formationAllenResultName() ); mainGrid->nncData()->makeStaticConnectionScalarResult( RiaDefines::formationAllanResultName() );
std::vector<double>& fnBinAllenNncResults = std::vector<double>& fnBinAllanNncResults =
mainGrid->nncData()->makeStaticConnectionScalarResult( RiaDefines::formationBinaryAllenResultName() ); mainGrid->nncData()->makeStaticConnectionScalarResult( RiaDefines::formationBinaryAllanResultName() );
// Associate them with eclipse result address // Associate them with eclipse result address
mainGrid->nncData()->setEclResultAddress( RiaDefines::formationAllenResultName(), fnAllenResultResAddr ); mainGrid->nncData()->setEclResultAddress( RiaDefines::formationAllanResultName(), fnAllanResultResAddr );
mainGrid->nncData()->setEclResultAddress( RiaDefines::formationBinaryAllenResultName(), fnBinAllenResAddr ); mainGrid->nncData()->setEclResultAddress( RiaDefines::formationBinaryAllanResultName(), fnBinAllanResAddr );
const std::vector<double>& fnData = cellResultsData->cellScalarResults( fnNamesResAddr, 0 ); 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, cellResultsData->addStaticScalarResult( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaDefines::formationAllenResultName(), RiaDefines::formationAllanResultName(),
false, false,
fnData.size() ); fnData.size() );
cellResultsData->addStaticScalarResult( RiaDefines::ResultCatType::ALLEN_DIAGRAMS, cellResultsData->addStaticScalarResult( RiaDefines::ResultCatType::ALLAN_DIAGRAMS,
RiaDefines::formationBinaryAllenResultName(), RiaDefines::formationBinaryAllanResultName(),
false, false,
fnData.size() ); fnData.size() );
std::vector<double>* alData = cellResultsData->modifiableCellScalarResult( fnAllenResultResAddr, 0 ); std::vector<double>* alData = cellResultsData->modifiableCellScalarResult( fnAllanResultResAddr, 0 );
std::vector<double>* binAlData = cellResultsData->modifiableCellScalarResult( fnBinAllenResAddr, 0 ); std::vector<double>* binAlData = cellResultsData->modifiableCellScalarResult( fnBinAllanResAddr, 0 );
( *alData ) = fnData; ( *alData ) = fnData;
@ -3164,18 +3164,18 @@ void RigCaseCellResultsData::computeAllenResults( RigCaseCellResultsData* cellRe
formationCombinationToCategory[formationCombination] = category; formationCombinationToCategory[formationCombination] = category;
} }
fnBinAllenNncResults[i] = 1.0; fnBinAllanNncResults[i] = 1.0;
} }
else else
{ {
category = formation1; 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 else
{ {
@ -3199,9 +3199,9 @@ void RigCaseCellResultsData::computeAllenResults( RigCaseCellResultsData* cellRe
binaryValue = 1.0; binaryValue = 1.0;
} }
fnAllenNncResults[i] = k1; fnAllanNncResults[i] = k1;
allAllenFormationResults[i] = k1; allAllanFormationResults[i] = k1;
fnBinAllenNncResults[i] = binaryValue; fnBinAllanNncResults[i] = binaryValue;
} }
#endif #endif
} }

8
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.h
View File

@ -41,7 +41,7 @@ class RigStatisticsDataCache;
class RigEclipseTimeStepInfo; class RigEclipseTimeStepInfo;
class RigEclipseCaseData; class RigEclipseCaseData;
class RigFormationNames; class RigFormationNames;
class RigAllenDiagramData; class RigAllanDiagramData;
class RimEclipseCase; class RimEclipseCase;
@ -60,7 +60,7 @@ public:
void setHdf5Filename( const QString& hdf5SourSimFilename ); void setHdf5Filename( const QString& hdf5SourSimFilename );
void setActiveFormationNames( RigFormationNames* activeFormationNames ); void setActiveFormationNames( RigFormationNames* activeFormationNames );
const RigFormationNames* activeFormationNames() const; const RigFormationNames* activeFormationNames() const;
RigAllenDiagramData* allenDiagramData(); RigAllanDiagramData* allanDiagramData();
void setMainGrid( RigMainGrid* ownerGrid ); void setMainGrid( RigMainGrid* ownerGrid );
void setActiveCellInfo( RigActiveCellInfo* activeCellInfo ); void setActiveCellInfo( RigActiveCellInfo* activeCellInfo );
@ -191,12 +191,12 @@ private:
RigStatisticsDataCache* statistics( const RigEclipseResultAddress& resVarAddr ); RigStatisticsDataCache* statistics( const RigEclipseResultAddress& resVarAddr );
static void computeAllenResults( RigCaseCellResultsData* cellResultsData, RigMainGrid* mainGrid ); static void computeAllanResults( RigCaseCellResultsData* cellResultsData, RigMainGrid* mainGrid );
private: private:
cvf::ref<RifReaderInterface> m_readerInterface; cvf::ref<RifReaderInterface> m_readerInterface;
cvf::cref<RigFormationNames> m_activeFormationNamesData; 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 std::vector<std::vector<std::vector<double>>> m_cellScalarResults; ///< Scalar results on the complete reservoir for
///< each Result index (ResultVariable) and timestep ///< 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 "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h" #include "RigCaseCellResultsData.h"
@ -30,7 +30,7 @@
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigEclipseAllenFaultsStatCalc::RigEclipseAllenFaultsStatCalc( RigNNCData* cellResultsData, RigEclipseAllanFaultsStatCalc::RigEclipseAllanFaultsStatCalc( RigNNCData* cellResultsData,
const RigEclipseResultAddress& scalarResultIndex ) const RigEclipseResultAddress& scalarResultIndex )
: m_caseData( cellResultsData ) : m_caseData( cellResultsData )
, m_resultAddress( scalarResultIndex ) , 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 ); MinMaxAccumulator acc( min, max );
traverseCells( acc, timeStepIndex ); 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 ); PosNegAccumulator acc( pos, neg );
traverseCells( acc, timeStepIndex ); 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 ); SumCountAccumulator acc( valueSum, sampleCount );
traverseCells( acc, timeStepIndex ); 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 ) RigHistogramCalculator& histogramCalculator )
{ {
traverseCells( histogramCalculator, timeStepIndex ); 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; UniqueValueAccumulator acc;
traverseCells( acc, timeStepIndex ); 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; 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" #include "cvfArray.h"
class RigEclipseAllenFaultsStatCalc : public RigStatisticsCalculator class RigEclipseAllanFaultsStatCalc : public RigStatisticsCalculator
{ {
public: public:
RigEclipseAllenFaultsStatCalc( RigNNCData* cellResultsData, const RigEclipseResultAddress& scalarResultIndex ); RigEclipseAllanFaultsStatCalc( RigNNCData* cellResultsData, const RigEclipseResultAddress& scalarResultIndex );
void minMaxCellScalarValues( size_t timeStepIndex, double& min, double& max ) override; void minMaxCellScalarValues( size_t timeStepIndex, double& min, double& max ) override;
void posNegClosestToZero( size_t timeStepIndex, double& pos, double& neg ) 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 RimEclipseCase;
class RigVirtualPerforationTransmissibilities; class RigVirtualPerforationTransmissibilities;
class RigEquil; class RigEquil;
class RigAllenDiagramData; class RigAllanDiagramData;
struct RigWellResultPoint; struct RigWellResultPoint;
@ -89,7 +89,7 @@ public:
void setActiveFormationNames( RigFormationNames* activeFormationNames ); void setActiveFormationNames( RigFormationNames* activeFormationNames );
const RigFormationNames* activeFormationNames() const; const RigFormationNames* activeFormationNames() const;
const std::vector<QString> formationNames() const; const std::vector<QString> formationNames() const;
RigAllenDiagramData* allenDiagramData(); RigAllanDiagramData* allanDiagramData();
void setSimWellData( const cvf::Collection<RigSimWellData>& data ); void setSimWellData( const cvf::Collection<RigSimWellData>& data );
const cvf::Collection<RigSimWellData>& wellResults() const { return m_simWellData; } const cvf::Collection<RigSimWellData>& wellResults() const { return m_simWellData; }

12
ApplicationCode/UserInterface/RiuResultTextBuilder.cpp
View File

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