OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-10 07:26:03 -06:00
Code Issues Packages Projects Releases Wiki Activity

Janitor : Apply clang-format fixes on codebase in ApplicationCode

Browse Source
This commit is contained in:
Magne Sjaastad 2019-11-04 11:34:34 +01:00
parent c5e3bc6898
commit 96a26662fc
77 changed files with 2339 additions and 2402 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/Application/RiaApplication.cpp
View File

@ -313,7 +313,7 @@ bool RiaApplication::openFile( const QString& fileName )
} }
else if ( fileType & RiaDefines::ANY_ECLIPSE_FILE ) else if ( fileType & RiaDefines::ANY_ECLIPSE_FILE )
{ {
loadingSucceded = RicImportGeneralDataFeature::openEclipseFilesFromFileNames( QStringList{ fileName }, true ); loadingSucceded = RicImportGeneralDataFeature::openEclipseFilesFromFileNames( QStringList{fileName}, true );
lastUsedDialogTag = RiaDefines::defaultDirectoryLabel( fileType ); lastUsedDialogTag = RiaDefines::defaultDirectoryLabel( fileType );
} }

1
ApplicationCode/Application/Tools/RiaOptionItemFactory.cpp
View File

@ -29,7 +29,6 @@ void RiaOptionItemFactory::appendOptionItemFromViewNameAndCaseName( Rim3dView*
{ {
if ( !view || !optionItems ) return; if ( !view || !optionItems ) return;
QString displayName = view->autoName(); QString displayName = view->autoName();
caf::QIconProvider iconProvider = view->uiCapability()->uiIconProvider(); caf::QIconProvider iconProvider = view->uiCapability()->uiIconProvider();

6
ApplicationCode/Application/Tools/WellPathTools/RiaWellPlanCalculator.cpp
View File

@ -33,7 +33,7 @@ RiaWellPlanCalculator::RiaWellPlanCalculator( const cvf::Vec3d& sta
{ {
if ( m_lineArcEndPoints.size() < 2 ) return; if ( m_lineArcEndPoints.size() < 2 ) return;
WellPlanSegment segment = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }; WellPlanSegment segment = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
RiaOffshoreSphericalCoords startAziIncRad( m_startTangent ); RiaOffshoreSphericalCoords startAziIncRad( m_startTangent );
segment.inc = cvf::Math::toDegrees( startAziIncRad.inc() ); segment.inc = cvf::Math::toDegrees( startAziIncRad.inc() );
@ -77,7 +77,7 @@ void RiaWellPlanCalculator::addSegment( cvf::Vec3d t1, cvf::Vec3d p1, cvf::Vec3d
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RiaWellPlanCalculator::addLineSegment( cvf::Vec3d p1, cvf::Vec3d p2, cvf::Vec3d* endTangent ) void RiaWellPlanCalculator::addLineSegment( cvf::Vec3d p1, cvf::Vec3d p2, cvf::Vec3d* endTangent )
{ {
WellPlanSegment segment = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }; WellPlanSegment segment = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
cvf::Vec3d p1p2 = p2 - p1; cvf::Vec3d p1p2 = p2 - p1;
double length = p1p2.length(); double length = p1p2.length();
@ -107,7 +107,7 @@ void RiaWellPlanCalculator::addLineSegment( cvf::Vec3d p1, cvf::Vec3d p2, cvf::V
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RiaWellPlanCalculator::addArcSegment( cvf::Vec3d t1, cvf::Vec3d p1, cvf::Vec3d p2, cvf::Vec3d* endTangent ) void RiaWellPlanCalculator::addArcSegment( cvf::Vec3d t1, cvf::Vec3d p1, cvf::Vec3d p2, cvf::Vec3d* endTangent )
{ {
WellPlanSegment segment = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }; WellPlanSegment segment = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
RiaArcCurveCalculator arcCalc( p1, t1, p2 ); RiaArcCurveCalculator arcCalc( p1, t1, p2 );

124
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.cpp
View File

@ -646,7 +646,7 @@ std::map<QString, std::vector<RigCompletionData>>
auto it = completions.find( gridName ); auto it = completions.find( gridName );
if ( it == completions.end() ) if ( it == completions.end() )
{ {
completions.insert( std::pair<QString, std::vector<RigCompletionData>>( gridName, { completion } ) ); completions.insert( std::pair<QString, std::vector<RigCompletionData>>( gridName, {completion} ) );
} }
else else
{ {
@ -722,19 +722,19 @@ void RicWellPathExportCompletionDataFeatureImpl::exportWelspecsToFile( RimEclips
RifTextDataTableFormatter formatter( stream ); RifTextDataTableFormatter formatter( stream );
formatter.setColumnSpacing( 2 ); formatter.setColumnSpacing( 2 );
std::vector<RifTextDataTableColumn> header = { RifTextDataTableColumn( "Well" ), std::vector<RifTextDataTableColumn> header = {RifTextDataTableColumn( "Well" ),
RifTextDataTableColumn( "Grp" ), RifTextDataTableColumn( "Grp" ),
RifTextDataTableColumn( "I" ), RifTextDataTableColumn( "I" ),
RifTextDataTableColumn( "J" ), RifTextDataTableColumn( "J" ),
RifTextDataTableColumn( "RefDepth" ), RifTextDataTableColumn( "RefDepth" ),
RifTextDataTableColumn( "Type" ), RifTextDataTableColumn( "Type" ),
RifTextDataTableColumn( "DrainRad" ), RifTextDataTableColumn( "DrainRad" ),
RifTextDataTableColumn( "GasInEq" ), RifTextDataTableColumn( "GasInEq" ),
RifTextDataTableColumn( "AutoShut" ), RifTextDataTableColumn( "AutoShut" ),
RifTextDataTableColumn( "XFlow" ), RifTextDataTableColumn( "XFlow" ),
RifTextDataTableColumn( "FluidPVT" ), RifTextDataTableColumn( "FluidPVT" ),
RifTextDataTableColumn( "HydSDens" ), RifTextDataTableColumn( "HydSDens" ),
RifTextDataTableColumn( "FluidInPlReg" ) }; RifTextDataTableColumn( "FluidInPlReg" )};
formatter.keyword( "WELSPECS" ); formatter.keyword( "WELSPECS" );
formatter.header( header ); formatter.header( header );
@ -787,20 +787,20 @@ void RicWellPathExportCompletionDataFeatureImpl::exportWelspeclToFile(
RifTextDataTableFormatter formatter( stream ); RifTextDataTableFormatter formatter( stream );
formatter.setColumnSpacing( 2 ); formatter.setColumnSpacing( 2 );
std::vector<RifTextDataTableColumn> header = { RifTextDataTableColumn( "Well" ), std::vector<RifTextDataTableColumn> header = {RifTextDataTableColumn( "Well" ),
RifTextDataTableColumn( "Grp" ), RifTextDataTableColumn( "Grp" ),
RifTextDataTableColumn( "LGR" ), RifTextDataTableColumn( "LGR" ),
RifTextDataTableColumn( "I" ), RifTextDataTableColumn( "I" ),
RifTextDataTableColumn( "J" ), RifTextDataTableColumn( "J" ),
RifTextDataTableColumn( "RefDepth" ), RifTextDataTableColumn( "RefDepth" ),
RifTextDataTableColumn( "Type" ), RifTextDataTableColumn( "Type" ),
RifTextDataTableColumn( "DrainRad" ), RifTextDataTableColumn( "DrainRad" ),
RifTextDataTableColumn( "GasInEq" ), RifTextDataTableColumn( "GasInEq" ),
RifTextDataTableColumn( "AutoShut" ), RifTextDataTableColumn( "AutoShut" ),
RifTextDataTableColumn( "XFlow" ), RifTextDataTableColumn( "XFlow" ),
RifTextDataTableColumn( "FluidPVT" ), RifTextDataTableColumn( "FluidPVT" ),
RifTextDataTableColumn( "HydSDens" ), RifTextDataTableColumn( "HydSDens" ),
RifTextDataTableColumn( "FluidInPlReg" ) }; RifTextDataTableColumn( "FluidInPlReg" )};
formatter.keyword( "WELSPECL" ); formatter.keyword( "WELSPECL" );
formatter.header( header ); formatter.header( header );
@ -965,45 +965,45 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompdatTableUsingFormatte
if ( gridName.isEmpty() ) if ( gridName.isEmpty() )
{ {
header = header =
{ RifTextDataTableColumn( "Well" ), {RifTextDataTableColumn( "Well" ),
RifTextDataTableColumn( "I" ), RifTextDataTableColumn( "I" ),
RifTextDataTableColumn( "J" ), RifTextDataTableColumn( "J" ),
RifTextDataTableColumn( "K1" ), RifTextDataTableColumn( "K1" ),
RifTextDataTableColumn( "K2" ), RifTextDataTableColumn( "K2" ),
RifTextDataTableColumn( "Status" ), RifTextDataTableColumn( "Status" ),
RifTextDataTableColumn( "SAT" ), RifTextDataTableColumn( "SAT" ),
RifTextDataTableColumn( "TR", RifTextDataTableColumn( "TR",
RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ), RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ),
RifTextDataTableColumn( "DIAM" ), RifTextDataTableColumn( "DIAM" ),
RifTextDataTableColumn( "KH", RifTextDataTableColumn( "KH",
RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ), RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ),
RifTextDataTableColumn( "S" ), RifTextDataTableColumn( "S" ),
RifTextDataTableColumn( "Df", RifTextDataTableColumn( "Df",
RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ), RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ),
RifTextDataTableColumn( "DIR" ) }; RifTextDataTableColumn( "DIR" )};
formatter.keyword( "COMPDAT" ); formatter.keyword( "COMPDAT" );
} }
else else
{ {
header = header =
{ RifTextDataTableColumn( "Well" ), {RifTextDataTableColumn( "Well" ),
RifTextDataTableColumn( "LgrName" ), RifTextDataTableColumn( "LgrName" ),
RifTextDataTableColumn( "I" ), RifTextDataTableColumn( "I" ),
RifTextDataTableColumn( "J" ), RifTextDataTableColumn( "J" ),
RifTextDataTableColumn( "K1" ), RifTextDataTableColumn( "K1" ),
RifTextDataTableColumn( "K2" ), RifTextDataTableColumn( "K2" ),
RifTextDataTableColumn( "Status" ), RifTextDataTableColumn( "Status" ),
RifTextDataTableColumn( "SAT" ), RifTextDataTableColumn( "SAT" ),
RifTextDataTableColumn( "TR", RifTextDataTableColumn( "TR",
RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ), RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ),
RifTextDataTableColumn( "DIAM" ), RifTextDataTableColumn( "DIAM" ),
RifTextDataTableColumn( "KH", RifTextDataTableColumn( "KH",
RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ), RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ),
RifTextDataTableColumn( "S" ), RifTextDataTableColumn( "S" ),
RifTextDataTableColumn( "Df", RifTextDataTableColumn( "Df",
RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ), RifTextDataTableDoubleFormatting( RifTextDataTableDoubleFormat::RIF_SCIENTIFIC ) ),
RifTextDataTableColumn( "DIR" ) }; RifTextDataTableColumn( "DIR" )};
formatter.keyword( "COMPDATL" ); formatter.keyword( "COMPDATL" );
} }
@ -1270,7 +1270,7 @@ void RicWellPathExportCompletionDataFeatureImpl::appendCompletionData(
{ {
completionData->insert( completionData->insert(
std::pair<size_t, std::vector<RigCompletionData>>( completion.completionDataGridCell().globalCellIndex(), std::pair<size_t, std::vector<RigCompletionData>>( completion.completionDataGridCell().globalCellIndex(),
std::vector<RigCompletionData>{ completion } ) ); std::vector<RigCompletionData>{completion} ) );
} }
} }
} }

90
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportMswCompletionsImpl.cpp
View File

@ -335,15 +335,13 @@ void RicWellPathExportMswCompletionsImpl::generateWelsegsTable( RifTextDataTable
} }
{ {
generateWelsegsSegments( formatter, exportInfo, {RigCompletionData::FISHBONES_ICD, RigCompletionData::FISHBONES} );
generateWelsegsSegments( formatter, exportInfo, {RigCompletionData::FRACTURE} );
generateWelsegsSegments( formatter, generateWelsegsSegments( formatter,
exportInfo, exportInfo,
{ RigCompletionData::FISHBONES_ICD, RigCompletionData::FISHBONES } ); {RigCompletionData::PERFORATION_ICD,
generateWelsegsSegments( formatter, exportInfo, { RigCompletionData::FRACTURE } ); RigCompletionData::PERFORATION_ICV,
generateWelsegsSegments( formatter, RigCompletionData::PERFORATION_AICD} );
exportInfo,
{ RigCompletionData::PERFORATION_ICD,
RigCompletionData::PERFORATION_ICV,
RigCompletionData::PERFORATION_AICD } );
} }
formatter.tableCompleted(); formatter.tableCompleted();
@ -476,8 +474,8 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegTables( RifTextDataTabl
*/ */
{ {
std::set<RigCompletionData::CompletionType> fishbonesTypes = { RigCompletionData::FISHBONES_ICD, std::set<RigCompletionData::CompletionType> fishbonesTypes = {RigCompletionData::FISHBONES_ICD,
RigCompletionData::FISHBONES }; RigCompletionData::FISHBONES};
generateCompsegTable( formatter, exportInfo, false, fishbonesTypes ); generateCompsegTable( formatter, exportInfo, false, fishbonesTypes );
if ( exportInfo.hasSubGridIntersections() ) if ( exportInfo.hasSubGridIntersections() )
{ {
@ -486,7 +484,7 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegTables( RifTextDataTabl
} }
{ {
std::set<RigCompletionData::CompletionType> fractureTypes = { RigCompletionData::FRACTURE }; std::set<RigCompletionData::CompletionType> fractureTypes = {RigCompletionData::FRACTURE};
generateCompsegTable( formatter, exportInfo, false, fractureTypes ); generateCompsegTable( formatter, exportInfo, false, fractureTypes );
if ( exportInfo.hasSubGridIntersections() ) if ( exportInfo.hasSubGridIntersections() )
{ {
@ -495,10 +493,10 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegTables( RifTextDataTabl
} }
{ {
std::set<RigCompletionData::CompletionType> perforationTypes = { RigCompletionData::PERFORATION, std::set<RigCompletionData::CompletionType> perforationTypes = {RigCompletionData::PERFORATION,
RigCompletionData::PERFORATION_ICD, RigCompletionData::PERFORATION_ICD,
RigCompletionData::PERFORATION_ICV, RigCompletionData::PERFORATION_ICV,
RigCompletionData::PERFORATION_AICD }; RigCompletionData::PERFORATION_AICD};
generateCompsegTable( formatter, exportInfo, false, perforationTypes ); generateCompsegTable( formatter, exportInfo, false, perforationTypes );
if ( exportInfo.hasSubGridIntersections() ) if ( exportInfo.hasSubGridIntersections() )
{ {
@ -602,7 +600,7 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegHeader( RifTextDataTabl
} }
{ {
std::vector<RifTextDataTableColumn> header = { RifTextDataTableColumn( "Name" ) }; std::vector<RifTextDataTableColumn> header = {RifTextDataTableColumn( "Name" )};
formatter.header( header ); formatter.header( header );
formatter.add( exportInfo.wellPath()->completions()->wellNameForExport() ); formatter.add( exportInfo.wellPath()->completions()->wellNameForExport() );
formatter.rowCompleted(); formatter.rowCompleted();
@ -615,15 +613,15 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegHeader( RifTextDataTabl
allHeaders.push_back( RifTextDataTableColumn( "Grid" ) ); allHeaders.push_back( RifTextDataTableColumn( "Grid" ) );
} }
std::vector<RifTextDataTableColumn> commonHeaders = { RifTextDataTableColumn( "I" ), std::vector<RifTextDataTableColumn> commonHeaders = {RifTextDataTableColumn( "I" ),
RifTextDataTableColumn( "J" ), RifTextDataTableColumn( "J" ),
RifTextDataTableColumn( "K" ), RifTextDataTableColumn( "K" ),
RifTextDataTableColumn( "Branch no" ), RifTextDataTableColumn( "Branch no" ),
RifTextDataTableColumn( "Start Length" ), RifTextDataTableColumn( "Start Length" ),
RifTextDataTableColumn( "End Length" ), RifTextDataTableColumn( "End Length" ),
RifTextDataTableColumn( "Dir Pen" ), RifTextDataTableColumn( "Dir Pen" ),
RifTextDataTableColumn( "End Range" ), RifTextDataTableColumn( "End Range" ),
RifTextDataTableColumn( "Connection Depth" ) }; RifTextDataTableColumn( "Connection Depth" )};
allHeaders.insert( allHeaders.end(), commonHeaders.begin(), commonHeaders.end() ); allHeaders.insert( allHeaders.end(), commonHeaders.begin(), commonHeaders.end() );
formatter.header( allHeaders ); formatter.header( allHeaders );
} }
@ -711,27 +709,27 @@ void RicWellPathExportMswCompletionsImpl::generateWsegAicdTable( RifTextDataTabl
if ( !foundValve ) if ( !foundValve )
{ {
std::vector<QString> columnDescriptions = std::vector<QString> columnDescriptions =
{ "Well Name", {"Well Name",
"Segment Number", "Segment Number",
"Segment Number", "Segment Number",
"Strength of AICD", "Strength of AICD",
"Length of AICD", "Length of AICD",
"Density of Calibration Fluid", "Density of Calibration Fluid",
"Viscosity of Calibration Fluid", "Viscosity of Calibration Fluid",
"Critical water in liquid fraction for emulsions viscosity model", "Critical water in liquid fraction for emulsions viscosity model",
"Emulsion viscosity transition region", "Emulsion viscosity transition region",
"Max ratio of emulsion viscosity to continuous phase viscosity", "Max ratio of emulsion viscosity to continuous phase viscosity",
"Flow scaling factor method", "Flow scaling factor method",
"Maximum flowrate for AICD device", "Maximum flowrate for AICD device",
"Volume flow rate exponent, x", "Volume flow rate exponent, x",
"Viscosity function exponent, y", "Viscosity function exponent, y",
"Device OPEN/SHUT", "Device OPEN/SHUT",
"Exponent of the oil flowing fraction in the density mixture calculation", "Exponent of the oil flowing fraction in the density mixture calculation",
"Exponent of the water flowing fraction in the density mixture calculation", "Exponent of the water flowing fraction in the density mixture calculation",
"Exponent of the gas flowing fraction in the density mixture calculation", "Exponent of the gas flowing fraction in the density mixture calculation",
"Exponent of the oil flowing fraction in the density viscosity calculation", "Exponent of the oil flowing fraction in the density viscosity calculation",
"Exponent of the water flowing fraction in the density viscosity calculation", "Exponent of the water flowing fraction in the density viscosity calculation",
"Exponent of the gas flowing fraction in the density viscosity calculation" }; "Exponent of the gas flowing fraction in the density viscosity calculation"};
tighterFormatter.keyword( "WSEGAICD" ); tighterFormatter.keyword( "WSEGAICD" );
tighterFormatter.comment( "Column Overview:" ); tighterFormatter.comment( "Column Overview:" );
@ -1011,7 +1009,7 @@ RicMswExportInfo RicWellPathExportMswCompletionsImpl::generateFracturesMswExport
RicExportFractureCompletionsImpl::generateCompdatValues( caseToApply, RicExportFractureCompletionsImpl::generateCompdatValues( caseToApply,
wellPath->completions()->wellNameForExport(), wellPath->completions()->wellNameForExport(),
wellPath->wellPathGeometry(), wellPath->wellPathGeometry(),
{ fracture }, {fracture},
nullptr, nullptr,
nullptr ); nullptr );

2
ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelFeature.cpp
View File

@ -164,7 +164,7 @@ void RicExportEclipseSectorModelFeature::executeCommand( RimEclipseView*
QString fileName = dirPath.absoluteFilePath( keyword + ".GRDECL" ); QString fileName = dirPath.absoluteFilePath( keyword + ".GRDECL" );
bool worked = RifEclipseInputFileTools::exportKeywords( fileName, bool worked = RifEclipseInputFileTools::exportKeywords( fileName,
view->eclipseCase()->eclipseCaseData(), view->eclipseCase()->eclipseCaseData(),
{ keyword }, {keyword},
fileWriteMode, fileWriteMode,
min, min,
max, max,

34
ApplicationCode/Commands/ExportCommands/RicExportLgrFeature.cpp
View File

@ -136,8 +136,8 @@ class IjkBoundingBox
public: public:
IjkBoundingBox() IjkBoundingBox()
: m_min( { MAX_SIZE_T, MAX_SIZE_T, MAX_SIZE_T } ) : m_min( {MAX_SIZE_T, MAX_SIZE_T, MAX_SIZE_T} )
, m_max( { MAX_SIZE_T, MAX_SIZE_T, MAX_SIZE_T } ) , m_max( {MAX_SIZE_T, MAX_SIZE_T, MAX_SIZE_T} )
{ {
} }
@ -172,7 +172,7 @@ public:
{ {
if ( !isValid() ) if ( !isValid() )
{ {
m_min = m_max = { i, j, k }; m_min = m_max = {i, j, k};
} }
else else
{ {
@ -370,16 +370,16 @@ void RicExportLgrFeature::writeLgrs( QTextStream& stream, const std::vector<LgrI
RifTextDataTableFormatter formatter( stream ); RifTextDataTableFormatter formatter( stream );
formatter.comment( QString( "LGR: " ) + lgrInfo.name ); formatter.comment( QString( "LGR: " ) + lgrInfo.name );
formatter.keyword( "CARFIN" ); formatter.keyword( "CARFIN" );
formatter.header( { RifTextDataTableColumn( "Name" ), formatter.header( {RifTextDataTableColumn( "Name" ),
RifTextDataTableColumn( "I1" ), RifTextDataTableColumn( "I1" ),
RifTextDataTableColumn( "I2" ), RifTextDataTableColumn( "I2" ),
RifTextDataTableColumn( "J1" ), RifTextDataTableColumn( "J1" ),
RifTextDataTableColumn( "J2" ), RifTextDataTableColumn( "J2" ),
RifTextDataTableColumn( "K1" ), RifTextDataTableColumn( "K1" ),
RifTextDataTableColumn( "K2" ), RifTextDataTableColumn( "K2" ),
RifTextDataTableColumn( "NX" ), RifTextDataTableColumn( "NX" ),
RifTextDataTableColumn( "NY" ), RifTextDataTableColumn( "NY" ),
RifTextDataTableColumn( "NZ" ) } ); RifTextDataTableColumn( "NZ" )} );
formatter.add( lgrInfo.name ); formatter.add( lgrInfo.name );
formatter.addOneBasedCellIndex( lgrInfo.mainGridStartCell.i() ); formatter.addOneBasedCellIndex( lgrInfo.mainGridStartCell.i() );
@ -553,7 +553,7 @@ std::vector<LgrInfo>
for ( const auto& intersectionCell : intersectingCells ) for ( const auto& intersectionCell : intersectingCells )
{ {
auto lgrName = lgrNameFactory.newName( "", lgrId ); auto lgrName = lgrNameFactory.newName( "", lgrId );
lgrs.push_back( buildLgr( lgrId++, lgrName, eclipseCase, wellPath->name(), { intersectionCell }, lgrSizes ) ); lgrs.push_back( buildLgr( lgrId++, lgrName, eclipseCase, wellPath->name(), {intersectionCell}, lgrSizes ) );
} }
return lgrs; return lgrs;
} }
@ -944,9 +944,9 @@ const RigGridBase* RicExportLgrFeature::hostGrid( const RigMainGrid* mainGrid, s
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
LgrNameFactory::LgrNameFactory() LgrNameFactory::LgrNameFactory()
{ {
m_counters = { { RigCompletionData::FRACTURE, { "FRAC", 1 } }, m_counters = {{RigCompletionData::FRACTURE, {"FRAC", 1}},
{ RigCompletionData::FISHBONES, { "FB", 1 } }, {RigCompletionData::FISHBONES, {"FB", 1}},
{ RigCompletionData::PERFORATION, { "PERF", 1 } } }; {RigCompletionData::PERFORATION, {"PERF", 1}}};
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

6
ApplicationCode/Commands/IntersectionBoxCommands/RicBoxManipulatorEventHandler.cpp
View File

@ -136,10 +136,10 @@ bool RicBoxManipulatorEventHandler::eventFilter( QObject* obj, QEvent* inputEven
{ {
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>( inputEvent ); QMouseEvent* mouseEvent = static_cast<QMouseEvent*>( inputEvent );
cvf::ref<cvf::RayIntersectSpec> rayIS = cvf::ref<cvf::RayIntersectSpec> rayIS = viewer->rayIntersectSpecFromWindowCoordinates( mouseEvent->pos().x(),
viewer->rayIntersectSpecFromWindowCoordinates( mouseEvent->pos().x(), mouseEvent->pos().y() ); mouseEvent->pos().y() );
if (rayIS.notNull()) if ( rayIS.notNull() )
{ {
m_partManager->updateManipulatorFromRay( rayIS->ray() ); m_partManager->updateManipulatorFromRay( rayIS->ray() );

4
ApplicationCode/Commands/IntersectionBoxCommands/RicBoxManipulatorEventHandler.h
View File

@ -52,7 +52,7 @@ public:
explicit RicBoxManipulatorEventHandler( caf::Viewer* viewer ); explicit RicBoxManipulatorEventHandler( caf::Viewer* viewer );
~RicBoxManipulatorEventHandler() override; ~RicBoxManipulatorEventHandler() override;
void registerInAdditionalViewer( caf::Viewer* viewer); void registerInAdditionalViewer( caf::Viewer* viewer );
void setOrigin( const cvf::Vec3d& origin ); void setOrigin( const cvf::Vec3d& origin );
void setSize( const cvf::Vec3d& size ); void setSize( const cvf::Vec3d& size );
@ -67,7 +67,7 @@ protected:
bool eventFilter( QObject* obj, QEvent* event ) override; bool eventFilter( QObject* obj, QEvent* event ) override;
private: private:
QPointer<caf::Viewer> m_viewer; QPointer<caf::Viewer> m_viewer;
std::vector<QPointer<caf::Viewer>> m_otherViewers; std::vector<QPointer<caf::Viewer>> m_otherViewers;
cvf::ref<caf::BoxManipulatorPartManager> m_partManager; cvf::ref<caf::BoxManipulatorPartManager> m_partManager;

4
ApplicationCode/Commands/IntersectionBoxCommands/RicIntersectionBoxAtPosFeature.cpp
View File

@ -51,7 +51,7 @@ bool RicIntersectionBoxAtPosFeature::isCommandEnabled()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicIntersectionBoxAtPosFeature::onActionTriggered( bool isChecked ) void RicIntersectionBoxAtPosFeature::onActionTriggered( bool isChecked )
{ {
RimGridView* activeView = RiaApplication::instance()->activeGridView(); RimGridView* activeView = RiaApplication::instance()->activeGridView();
RimGridView* activeMainOrComparisonView = RiaApplication::instance()->activeMainOrComparisonGridView(); RimGridView* activeMainOrComparisonView = RiaApplication::instance()->activeMainOrComparisonGridView();
if ( activeMainOrComparisonView ) if ( activeMainOrComparisonView )
{ {
@ -70,7 +70,7 @@ void RicIntersectionBoxAtPosFeature::onActionTriggered( bool isChecked )
coll->updateConnectedEditors(); coll->updateConnectedEditors();
RiuMainWindow::instance()->selectAsCurrentItem( intersectionBox, false ); RiuMainWindow::instance()->selectAsCurrentItem( intersectionBox, false );
activeMainOrComparisonView->showGridCells(false); activeMainOrComparisonView->showGridCells( false );
RiuMainWindow::instance()->refreshDrawStyleActions(); RiuMainWindow::instance()->refreshDrawStyleActions();
activeView->scheduleCreateDisplayModelAndRedraw(); activeView->scheduleCreateDisplayModelAndRedraw();

3
ApplicationCode/Commands/IntersectionBoxCommands/RicIntersectionBoxXSliceFeature.cpp
View File

@ -53,7 +53,8 @@ bool RicIntersectionBoxXSliceFeature::isCommandEnabled()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicIntersectionBoxXSliceFeature::onActionTriggered( bool isChecked ) void RicIntersectionBoxXSliceFeature::onActionTriggered( bool isChecked )
{ {
RicIntersectionFeatureImpl::createIntersectionBoxSlize("X-slice (Intersection box)", RimIntersectionBox::PLANE_STATE_X); RicIntersectionFeatureImpl::createIntersectionBoxSlize( "X-slice (Intersection box)",
RimIntersectionBox::PLANE_STATE_X );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

3
ApplicationCode/Commands/IntersectionBoxCommands/RicIntersectionBoxYSliceFeature.cpp
View File

@ -53,7 +53,8 @@ bool RicIntersectionBoxYSliceFeature::isCommandEnabled()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicIntersectionBoxYSliceFeature::onActionTriggered( bool isChecked ) void RicIntersectionBoxYSliceFeature::onActionTriggered( bool isChecked )
{ {
RicIntersectionFeatureImpl::createIntersectionBoxSlize("Y-slice (Intersection box)", RimIntersectionBox::PLANE_STATE_Y); RicIntersectionFeatureImpl::createIntersectionBoxSlize( "Y-slice (Intersection box)",
RimIntersectionBox::PLANE_STATE_Y );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

3
ApplicationCode/Commands/IntersectionBoxCommands/RicIntersectionBoxZSliceFeature.cpp
View File

@ -53,7 +53,8 @@ bool RicIntersectionBoxZSliceFeature::isCommandEnabled()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicIntersectionBoxZSliceFeature::onActionTriggered( bool isChecked ) void RicIntersectionBoxZSliceFeature::onActionTriggered( bool isChecked )
{ {
RicIntersectionFeatureImpl::createIntersectionBoxSlize("Z-slice (Intersection box)", RimIntersectionBox::PLANE_STATE_Z); RicIntersectionFeatureImpl::createIntersectionBoxSlize( "Z-slice (Intersection box)",
RimIntersectionBox::PLANE_STATE_Z );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

11
ApplicationCode/Commands/IntersectionBoxCommands/RicIntersectionFeatureImpl.cpp
View File

@ -28,18 +28,19 @@
#include "RiuViewerCommands.h" #include "RiuViewerCommands.h"
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicIntersectionFeatureImpl::createIntersectionBoxSlize(const QString& name, RimIntersectionBox::SinglePlaneState plane) void RicIntersectionFeatureImpl::createIntersectionBoxSlize( const QString& name,
RimIntersectionBox::SinglePlaneState plane )
{ {
RimGridView* activeView = RiaApplication::instance()->activeGridView(); RimGridView* activeView = RiaApplication::instance()->activeGridView();
RimGridView* activeMainOrComparisonView = RiaApplication::instance()->activeMainOrComparisonGridView(); RimGridView* activeMainOrComparisonView = RiaApplication::instance()->activeMainOrComparisonGridView();
if ( activeMainOrComparisonView ) if ( activeMainOrComparisonView )
{ {
RimIntersectionCollection* coll = activeMainOrComparisonView->crossSectionCollection(); RimIntersectionCollection* coll = activeMainOrComparisonView->crossSectionCollection();
CVF_ASSERT( coll ); CVF_ASSERT( coll );
cvf::Vec3d domainCoord = activeView->viewer()->viewerCommands()->lastPickPositionInDomainCoords(); cvf::Vec3d domainCoord = activeView->viewer()->viewerCommands()->lastPickPositionInDomainCoords();
RimIntersectionBox* intersectionBox = new RimIntersectionBox(); RimIntersectionBox* intersectionBox = new RimIntersectionBox();
@ -49,7 +50,7 @@ void RicIntersectionFeatureImpl::createIntersectionBoxSlize(const QString& name,
intersectionBox->setToDefaultSizeSlice( plane, domainCoord ); intersectionBox->setToDefaultSizeSlice( plane, domainCoord );
coll->updateConnectedEditors(); coll->updateConnectedEditors();
activeMainOrComparisonView->showGridCells(false); activeMainOrComparisonView->showGridCells( false );
activeMainOrComparisonView->scheduleCreateDisplayModelAndRedraw(); activeMainOrComparisonView->scheduleCreateDisplayModelAndRedraw();
activeView->scheduleCreateDisplayModelAndRedraw(); activeView->scheduleCreateDisplayModelAndRedraw();

4
ApplicationCode/Commands/IntersectionBoxCommands/RicIntersectionFeatureImpl.h
View File

@ -24,6 +24,6 @@ class QString;
class RicIntersectionFeatureImpl class RicIntersectionFeatureImpl
{ {
public : public:
static void createIntersectionBoxSlize(const QString& name, RimIntersectionBox::SinglePlaneState plane ); static void createIntersectionBoxSlize( const QString& name, RimIntersectionBox::SinglePlaneState plane );
}; };

4
ApplicationCode/Commands/MeasurementCommands/RicToggleMeasurementModeFeature.cpp
View File

@ -21,9 +21,9 @@
#include "RiaGuiApplication.h" #include "RiaGuiApplication.h"
#include "Rim3dView.h" #include "Rim3dView.h"
#include "RimGridView.h"
#include "RimMeasurement.h" #include "RimMeasurement.h"
#include "RimProject.h" #include "RimProject.h"
#include "RimGridView.h"
#include "cafCmdFeatureManager.h" #include "cafCmdFeatureManager.h"
#include "cafPdmUiPropertyViewDialog.h" #include "cafPdmUiPropertyViewDialog.h"
@ -124,7 +124,7 @@ Rim3dView* RicToggleMeasurementModeFeature::activeView() const
{ {
RiaApplication* app = RiaApplication::instance(); RiaApplication* app = RiaApplication::instance();
CAF_ASSERT( app ); CAF_ASSERT( app );
auto view = dynamic_cast<Rim3dView*>(app->activeMainOrComparisonGridView()); auto view = dynamic_cast<Rim3dView*>( app->activeMainOrComparisonGridView() );
return view; return view;
} }

4
ApplicationCode/Commands/RicGeoMechPropertyFilterFeatureImpl.cpp
View File

@ -68,7 +68,7 @@ void RicGeoMechPropertyFilterFeatureImpl::addPropertyFilter( RimGeoMechPropertyF
propertyFilterCollection->reservoirView()->scheduleCreateDisplayModelAndRedraw(); propertyFilterCollection->reservoirView()->scheduleCreateDisplayModelAndRedraw();
propertyFilterCollection->updateConnectedEditors(); propertyFilterCollection->updateConnectedEditors();
Riu3DMainWindowTools::selectAsCurrentItem( propertyFilter , false); Riu3DMainWindowTools::selectAsCurrentItem( propertyFilter, false );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -85,7 +85,7 @@ void RicGeoMechPropertyFilterFeatureImpl::insertPropertyFilter( RimGeoMechProper
propertyFilterCollection->reservoirView()->scheduleCreateDisplayModelAndRedraw(); propertyFilterCollection->reservoirView()->scheduleCreateDisplayModelAndRedraw();
propertyFilterCollection->updateConnectedEditors(); propertyFilterCollection->updateConnectedEditors();
Riu3DMainWindowTools::selectAsCurrentItem( propertyFilter , false); Riu3DMainWindowTools::selectAsCurrentItem( propertyFilter, false );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

8
ApplicationCode/Commands/RicSelectColorResult.cpp
View File

@ -68,11 +68,11 @@ bool RicSelectColorResult::isCommandEnabled()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicSelectColorResult::onActionTriggered( bool isChecked ) void RicSelectColorResult::onActionTriggered( bool isChecked )
{ {
Rim3dView* activeView = RiaApplication::instance()->activeMainOrComparisonGridView(); Rim3dView* activeView = RiaApplication::instance()->activeMainOrComparisonGridView();
bool isComparisonView = (activeView != RiaApplication::instance()->activeGridView()); bool isComparisonView = ( activeView != RiaApplication::instance()->activeGridView() );
Rim2dIntersectionView* int2dView = dynamic_cast<Rim2dIntersectionView*>( activeView ); Rim2dIntersectionView* int2dView = dynamic_cast<Rim2dIntersectionView*>( activeView );
RimGridView* gridView = nullptr; RimGridView* gridView = nullptr;
if ( int2dView ) if ( int2dView )
gridView = gridViewFrom2dIntersectionView( int2dView ); gridView = gridViewFrom2dIntersectionView( int2dView );

2
ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp
View File

@ -287,7 +287,7 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine( const QStrin
QStringList gridFileNames; QStringList gridFileNames;
QString ensembleColoringParameter; QString ensembleColoringParameter;
std::set<QString> validOptions = { "-help", "-h", "-nl", "-s", "-n", "-e", "-c", "-cl" }; std::set<QString> validOptions = {"-help", "-h", "-nl", "-s", "-n", "-e", "-c", "-cl"};
for ( int optionIdx = 0; optionIdx < arguments.size(); ++optionIdx ) for ( int optionIdx = 0; optionIdx < arguments.size(); ++optionIdx )
{ {

12
ApplicationCode/Commands/ViewLink/RicCompareTo3dViewFeature.cpp
View File

@ -44,9 +44,9 @@ void RicCompareTo3dViewFeature::onActionTriggered( bool isChecked )
RimGridView* activeView = RiaApplication::instance()->activeGridView(); RimGridView* activeView = RiaApplication::instance()->activeGridView();
QVariant userData = this->userData(); QVariant userData = this->userData();
auto view = static_cast<Rim3dView*>(userData.value<void*>()); auto view = static_cast<Rim3dView*>( userData.value<void*>() );
if (view && activeView) if ( view && activeView )
{ {
activeView->setComparisonView( view ); activeView->setComparisonView( view );
activeView->scheduleCreateDisplayModelAndRedraw(); activeView->scheduleCreateDisplayModelAndRedraw();
@ -60,15 +60,13 @@ void RicCompareTo3dViewFeature::setupActionLook( QAction* actionToSetup )
{ {
QVariant userData = actionToSetup->data(); QVariant userData = actionToSetup->data();
auto view = static_cast<Rim3dView*>(userData.value<void*>()); auto view = static_cast<Rim3dView*>( userData.value<void*>() );
if ( view ) if ( view )
{ {
actionToSetup->setIcon(view->uiIconProvider().icon() ); actionToSetup->setIcon( view->uiIconProvider().icon() );
} }
else else
{ {
actionToSetup->setIcon(QIcon(":/ComparisonView16x16.png")); actionToSetup->setIcon( QIcon( ":/ComparisonView16x16.png" ) );
} }
} }

2
ApplicationCode/Commands/ViewLink/RicCompareTo3dViewFeature.h
View File

@ -33,5 +33,3 @@ protected:
void onActionTriggered( bool isChecked ) override; void onActionTriggered( bool isChecked ) override;
void setupActionLook( QAction* actionToSetup ) override; void setupActionLook( QAction* actionToSetup ) override;
}; };

12
ApplicationCode/Commands/ViewLink/RicLinkViewFeature.cpp
View File

@ -103,7 +103,10 @@ public:
RicLinkVisibleViewsFeature::linkViews( m_viewsToLink ); RicLinkVisibleViewsFeature::linkViews( m_viewsToLink );
} }
const std::vector<RimGridView*>& viewsToLink() { return m_viewsToLink;} const std::vector<RimGridView*>& viewsToLink()
{
return m_viewsToLink;
}
private: private:
std::vector<RimGridView*> m_viewsToLink; std::vector<RimGridView*> m_viewsToLink;
@ -138,7 +141,6 @@ void RicLinkViewFeature::setupActionLook( QAction* actionToSetup )
RicLinkViewFeatureImpl cmdImpl; RicLinkViewFeatureImpl cmdImpl;
cmdImpl.prepareToExecute(); cmdImpl.prepareToExecute();
if ( cmdImpl.viewsToLink().size() >= 2u ) if ( cmdImpl.viewsToLink().size() >= 2u )
{ {
actionToSetup->setText( "Link Selected Views" ); actionToSetup->setText( "Link Selected Views" );
@ -147,13 +149,13 @@ void RicLinkViewFeature::setupActionLook( QAction* actionToSetup )
else else
{ {
actionToSetup->setText( "Link View" ); actionToSetup->setText( "Link View" );
if (RiaApplication::instance()->project()->viewLinkerCollection()->viewLinker()) if ( RiaApplication::instance()->project()->viewLinkerCollection()->viewLinker() )
{ {
actionToSetup->setIcon(QIcon(":/ControlledView16x16.png")); actionToSetup->setIcon( QIcon( ":/ControlledView16x16.png" ) );
} }
else else
{ {
actionToSetup->setIcon(QIcon(":/MasterView16x16.png")); actionToSetup->setIcon( QIcon( ":/MasterView16x16.png" ) );
} }
} }
} }

2
ApplicationCode/Commands/ViewLink/RicRemoveComparison3dViewFeature.cpp
View File

@ -85,5 +85,3 @@ void RicRemoveComparison3dViewFeature::setupActionLook( QAction* actionToSetup )
actionToSetup->setText( "Remove Comparison" ); actionToSetup->setText( "Remove Comparison" );
actionToSetup->setIcon( QIcon( ":/RemoveComparisonView16x16.png" ) ); actionToSetup->setIcon( QIcon( ":/RemoveComparisonView16x16.png" ) );
} }

2
ApplicationCode/Commands/ViewLink/RicRemoveComparison3dViewFeature.h
View File

@ -33,5 +33,3 @@ protected:
void onActionTriggered( bool isChecked ) override; void onActionTriggered( bool isChecked ) override;
void setupActionLook( QAction* actionToSetup ) override; void setupActionLook( QAction* actionToSetup ) override;
}; };

9
ApplicationCode/Commands/ViewLink/RicUnLinkViewFeature.cpp
View File

@ -30,8 +30,8 @@
#include "cafCmdFeatureManager.h" #include "cafCmdFeatureManager.h"
#include "cafSelectionManager.h" #include "cafSelectionManager.h"
#include <QAction>
#include "RimViewLinkerCollection.h" #include "RimViewLinkerCollection.h"
#include <QAction>
CAF_CMD_SOURCE_INIT( RicUnLinkViewFeature, "RicUnLinkViewFeature" ); CAF_CMD_SOURCE_INIT( RicUnLinkViewFeature, "RicUnLinkViewFeature" );
@ -68,7 +68,8 @@ void RicUnLinkViewFeature::onActionTriggered( bool isChecked )
{ {
viewController->applyRangeFilterCollectionByUserChoice(); viewController->applyRangeFilterCollectionByUserChoice();
delete viewController; delete viewController;
viewLinker->removeViewController( nullptr ); // Remove the slots in the vector that was set to nullptr by the destructor viewLinker->removeViewController(
nullptr ); // Remove the slots in the vector that was set to nullptr by the destructor
} }
else if ( viewLinker ) else if ( viewLinker )
{ {
@ -78,7 +79,7 @@ void RicUnLinkViewFeature::onActionTriggered( bool isChecked )
if ( firstControlledView ) if ( firstControlledView )
{ {
viewLinker->setMasterView(firstControlledView); viewLinker->setMasterView( firstControlledView );
viewLinker->updateDependentViews(); viewLinker->updateDependentViews();
} }
@ -86,7 +87,7 @@ void RicUnLinkViewFeature::onActionTriggered( bool isChecked )
{ {
// Remove the view linker object from the view linker collection // Remove the view linker object from the view linker collection
// viewLinkerCollection->viewLinker is a PdmChildField containing one RimViewLinker child object // viewLinkerCollection->viewLinker is a PdmChildField containing one RimViewLinker child object
RiaApplication::instance()->project()->viewLinkerCollection->viewLinker.removeChildObject(viewLinker); RiaApplication::instance()->project()->viewLinkerCollection->viewLinker.removeChildObject( viewLinker );
delete viewLinker; delete viewLinker;
} }

16
ApplicationCode/Commands/WellLogCommands/RicNewWellBoreStabilityPlotFeature.cpp
View File

@ -237,7 +237,7 @@ void RicNewWellBoreStabilityPlotFeature::createParametersTrack( RimWellBoreStabi
paramCurvesTrack->setChecked( false ); paramCurvesTrack->setChecked( false );
std::vector<QString> resultNames = RiaDefines::wellPathStabilityParameterNames(); std::vector<QString> resultNames = RiaDefines::wellPathStabilityParameterNames();
std::vector<cvf::Color3f> colors = { cvf::Color3f::CRIMSON, cvf::Color3f::DARK_YELLOW }; std::vector<cvf::Color3f> colors = {cvf::Color3f::CRIMSON, cvf::Color3f::DARK_YELLOW};
for ( size_t i = 0; i < resultNames.size(); ++i ) for ( size_t i = 0; i < resultNames.size(); ++i )
{ {
@ -283,11 +283,11 @@ void RicNewWellBoreStabilityPlotFeature::createStabilityCurvesTrack( RimWellBore
std::vector<QString> resultNames = RiaDefines::wellPathStabilityResultNames(); std::vector<QString> resultNames = RiaDefines::wellPathStabilityResultNames();
std::vector<cvf::Color3f> colors = { cvf::Color3f::BLUE, std::vector<cvf::Color3f> colors = {cvf::Color3f::BLUE,
cvf::Color3f::BROWN, cvf::Color3f::BROWN,
cvf::Color3f::RED, cvf::Color3f::RED,
cvf::Color3f::PURPLE, cvf::Color3f::PURPLE,
cvf::Color3f::DARK_GREEN }; cvf::Color3f::DARK_GREEN};
for ( size_t i = 0; i < resultNames.size(); ++i ) for ( size_t i = 0; i < resultNames.size(); ++i )
{ {
@ -327,9 +327,9 @@ void RicNewWellBoreStabilityPlotFeature::createAnglesTrack( RimWellBoreStability
const double angleIncrement = 90.0; const double angleIncrement = 90.0;
std::vector<QString> resultNames = RiaDefines::wellPathAngleResultNames(); std::vector<QString> resultNames = RiaDefines::wellPathAngleResultNames();
std::vector<cvf::Color3f> colors = { cvf::Color3f::GREEN, cvf::Color3f::ORANGE }; std::vector<cvf::Color3f> colors = {cvf::Color3f::GREEN, cvf::Color3f::ORANGE};
std::vector<RiuQwtPlotCurve::LineStyleEnum> lineStyles = { RiuQwtPlotCurve::STYLE_SOLID, RiuQwtPlotCurve::STYLE_DASH }; std::vector<RiuQwtPlotCurve::LineStyleEnum> lineStyles = {RiuQwtPlotCurve::STYLE_SOLID, RiuQwtPlotCurve::STYLE_DASH};
for ( size_t i = 0; i < resultNames.size(); ++i ) for ( size_t i = 0; i < resultNames.size(); ++i )
{ {

2
ApplicationCode/FileInterface/RifCsvUserDataParser.cpp
View File

@ -63,7 +63,7 @@ enum class CsvLineBasedColumnType
ERROR_VALUE, ERROR_VALUE,
COMMENTS COMMENTS
}; };
const std::vector<QString> CSV_LINE_BASED_COL_NAMES = { "DATE", "VECTOR", "VALUE", "ERROR", "COMMENTS" }; const std::vector<QString> CSV_LINE_BASED_COL_NAMES = {"DATE", "VECTOR", "VALUE", "ERROR", "COMMENTS"};
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///

8
ApplicationCode/FileInterface/RifReaderEnsembleStatisticsRft.cpp
View File

@ -59,10 +59,10 @@ std::set<RifEclipseRftAddress> RifReaderEnsembleStatisticsRft::eclipseRftAddress
} }
else if ( regularAddress.wellLogChannel() == RifEclipseRftAddress::PRESSURE ) else if ( regularAddress.wellLogChannel() == RifEclipseRftAddress::PRESSURE )
{ {
std::set<RifEclipseRftAddress::RftWellLogChannelType> statChannels = { RifEclipseRftAddress::PRESSURE_P10, std::set<RifEclipseRftAddress::RftWellLogChannelType> statChannels = {RifEclipseRftAddress::PRESSURE_P10,
RifEclipseRftAddress::PRESSURE_P50, RifEclipseRftAddress::PRESSURE_P50,
RifEclipseRftAddress::PRESSURE_P90, RifEclipseRftAddress::PRESSURE_P90,
RifEclipseRftAddress::PRESSURE_MEAN }; RifEclipseRftAddress::PRESSURE_MEAN};
for ( auto channel : statChannels ) for ( auto channel : statChannels )
{ {
statisticsAddresses.insert( statisticsAddresses.insert(

4
ApplicationCode/FileInterface/RifReaderFmuRft.cpp
View File

@ -330,7 +330,7 @@ std::set<QDateTime> RifReaderFmuRft::availableTimeSteps( const QString& wellName
auto it = m_allWellObservations.find( wellName ); auto it = m_allWellObservations.find( wellName );
if ( it != m_allWellObservations.end() ) if ( it != m_allWellObservations.end() )
{ {
return { it->second.dateTime }; return {it->second.dateTime};
} }
return {}; return {};
} }
@ -362,7 +362,7 @@ std::set<RifEclipseRftAddress::RftWellLogChannelType> RifReaderFmuRft::available
if ( !m_allWellObservations.empty() ) if ( !m_allWellObservations.empty() )
{ {
return { RifEclipseRftAddress::TVD, RifEclipseRftAddress::MD, RifEclipseRftAddress::PRESSURE }; return {RifEclipseRftAddress::TVD, RifEclipseRftAddress::MD, RifEclipseRftAddress::PRESSURE};
} }
return {}; return {};
} }

2
ApplicationCode/ProjectDataModel/Annotations/RimAnnotationCollection.cpp
View File

@ -225,7 +225,7 @@ void RimAnnotationCollection::updateViewAnnotationCollections()
for ( const auto* view : views ) for ( const auto* view : views )
{ {
if (view->annotationCollection()) if ( view->annotationCollection() )
{ {
view->annotationCollection()->onGlobalCollectionChanged( this ); view->annotationCollection()->onGlobalCollectionChanged( this );
} }

2
ApplicationCode/ProjectDataModel/Flow/RimFlowCharacteristicsPlot.cpp
View File

@ -787,7 +787,7 @@ QString RimFlowCharacteristicsPlot::curveDataAsText() const
std::vector<QDateTime> timeStepDates = m_case->timeStepDates(); std::vector<QDateTime> timeStepDates = m_case->timeStepDates();
std::vector<double> storageCapacitySamplingValues = { 0.08, 0.1, 0.2, 0.3, 0.4 }; std::vector<double> storageCapacitySamplingValues = {0.08, 0.1, 0.2, 0.3, 0.4};
size_t sampleCount = storageCapacitySamplingValues.size(); size_t sampleCount = storageCapacitySamplingValues.size();
for ( const auto& timeIndex : m_currentlyPlottedTimeSteps ) for ( const auto& timeIndex : m_currentlyPlottedTimeSteps )

4
ApplicationCode/ProjectDataModel/Flow/RimWellPltPlot.cpp
View File

@ -130,7 +130,7 @@ RimWellPltPlot::RimWellPltPlot()
CAF_PDM_InitFieldNoDefault( &m_phases, "Phases", "Phases", "", "", "" ); CAF_PDM_InitFieldNoDefault( &m_phases, "Phases", "Phases", "", "", "" );
m_phases.uiCapability()->setUiEditorTypeName( caf::PdmUiTreeSelectionEditor::uiEditorTypeName() ); m_phases.uiCapability()->setUiEditorTypeName( caf::PdmUiTreeSelectionEditor::uiEditorTypeName() );
m_phases = std::vector<caf::AppEnum<FlowPhase>>( { FLOW_PHASE_OIL, FLOW_PHASE_GAS, FLOW_PHASE_WATER } ); m_phases = std::vector<caf::AppEnum<FlowPhase>>( {FLOW_PHASE_OIL, FLOW_PHASE_GAS, FLOW_PHASE_WATER} );
m_phases.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::HIDDEN ); m_phases.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::HIDDEN );
m_nameConfig->setCustomName( "PLT Plot" ); m_nameConfig->setCustomName( "PLT Plot" );
@ -139,7 +139,7 @@ RimWellPltPlot::RimWellPltPlot()
m_doInitAfterLoad = false; m_doInitAfterLoad = false;
m_isOnLoad = true; m_isOnLoad = true;
setAvailableDepthTypes( { RimWellLogPlot::MEASURED_DEPTH } ); setAvailableDepthTypes( {RimWellLogPlot::MEASURED_DEPTH} );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

14
ApplicationCode/ProjectDataModel/Flow/RimWellRftPlot.cpp
View File

@ -342,7 +342,7 @@ void RimWellRftPlot::updateEditorsFromCurves()
selectedSources.insert( curveDef.address() ); selectedSources.insert( curveDef.address() );
auto newTimeStepMap = std::map<QDateTime, std::set<RifDataSourceForRftPlt>>{ auto newTimeStepMap = std::map<QDateTime, std::set<RifDataSourceForRftPlt>>{
{ curveDef.timeStep(), std::set<RifDataSourceForRftPlt>{ curveDef.address() } } }; {curveDef.timeStep(), std::set<RifDataSourceForRftPlt>{curveDef.address()}}};
RimWellPlotTools::addTimeStepsToMap( selectedTimeStepsMap, newTimeStepMap ); RimWellPlotTools::addTimeStepsToMap( selectedTimeStepsMap, newTimeStepMap );
selectedTimeSteps.insert( curveDef.timeStep() ); selectedTimeSteps.insert( curveDef.timeStep() );
} }
@ -1170,12 +1170,12 @@ void RimWellRftPlot::defineCurveColorsAndSymbols( const std::set<RiaRftPltCurveD
std::vector<cvf::Color3f> colorTable; std::vector<cvf::Color3f> colorTable;
RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector( &colorTable ); RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector( &colorTable );
std::vector<RiuQwtSymbol::PointSymbolEnum> symbolTable = { RiuQwtSymbol::SYMBOL_ELLIPSE, std::vector<RiuQwtSymbol::PointSymbolEnum> symbolTable = {RiuQwtSymbol::SYMBOL_ELLIPSE,
RiuQwtSymbol::SYMBOL_RECT, RiuQwtSymbol::SYMBOL_RECT,
RiuQwtSymbol::SYMBOL_DIAMOND, RiuQwtSymbol::SYMBOL_DIAMOND,
RiuQwtSymbol::SYMBOL_CROSS, RiuQwtSymbol::SYMBOL_CROSS,
RiuQwtSymbol::SYMBOL_XCROSS, RiuQwtSymbol::SYMBOL_XCROSS,
RiuQwtSymbol::SYMBOL_STAR1 }; RiuQwtSymbol::SYMBOL_STAR1};
// Add new curves // Add new curves
for ( const RiaRftPltCurveDefinition& curveDefToAdd : allCurveDefs ) for ( const RiaRftPltCurveDefinition& curveDefToAdd : allCurveDefs )

2
ApplicationCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlot.cpp
View File

@ -1023,7 +1023,7 @@ void RimGridCrossPlot::setShowInfoBox( bool enable )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::set<RimPlotAxisPropertiesInterface*> RimGridCrossPlot::allPlotAxes() const std::set<RimPlotAxisPropertiesInterface*> RimGridCrossPlot::allPlotAxes() const
{ {
return { m_xAxisProperties, m_yAxisProperties }; return {m_xAxisProperties, m_yAxisProperties};
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

8
ApplicationCode/ProjectDataModel/GridCrossPlots/RimGridCrossPlotDataSet.cpp
View File

@ -943,10 +943,10 @@ QList<caf::PdmOptionItemInfo>
} }
else if ( fieldNeedingOptions == &m_grouping ) else if ( fieldNeedingOptions == &m_grouping )
{ {
std::set<RigGridCrossPlotCurveGrouping> validOptions = { NO_GROUPING, std::set<RigGridCrossPlotCurveGrouping> validOptions = {NO_GROUPING,
GROUP_BY_TIME, GROUP_BY_TIME,
GROUP_BY_FORMATION, GROUP_BY_FORMATION,
GROUP_BY_RESULT }; GROUP_BY_RESULT};
if ( !hasMultipleTimeSteps() ) if ( !hasMultipleTimeSteps() )
{ {
validOptions.erase( GROUP_BY_TIME ); validOptions.erase( GROUP_BY_TIME );

4
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@ -562,7 +562,7 @@ QString Rim3dOverlayInfoConfig::caseInfoText( RimEclipseView* eclipseView )
QString totCellCount = QString::number( contourMap->contourMapProjection()->numberOfCells() ); QString totCellCount = QString::number( contourMap->contourMapProjection()->numberOfCells() );
cvf::uint validCellCount = contourMap->contourMapProjection()->numberOfValidCells(); cvf::uint validCellCount = contourMap->contourMapProjection()->numberOfValidCells();
QString activeCellCountText = QString::number( validCellCount ); QString activeCellCountText = QString::number( validCellCount );
QString aggregationType = contourMap->contourMapProjection()->resultAggregationText(); QString aggregationType = contourMap->contourMapProjection()->resultAggregationText();
QString weightingParameterString; QString weightingParameterString;
if ( contourMap->contourMapProjection()->weightingParameter() != "None" ) if ( contourMap->contourMapProjection()->weightingParameter() != "None" )
{ {
@ -630,7 +630,7 @@ QString Rim3dOverlayInfoConfig::caseInfoText( RimGeoMechView* geoMechView )
QString totCellCount = QString::number( contourMap->contourMapProjection()->numberOfCells() ); QString totCellCount = QString::number( contourMap->contourMapProjection()->numberOfCells() );
cvf::uint validCellCount = contourMap->contourMapProjection()->numberOfValidCells(); cvf::uint validCellCount = contourMap->contourMapProjection()->numberOfValidCells();
QString activeCellCountText = QString::number( validCellCount ); QString activeCellCountText = QString::number( validCellCount );
QString aggregationType = contourMap->contourMapProjection()->resultAggregationText(); QString aggregationType = contourMap->contourMapProjection()->resultAggregationText();
infoText += QString( "<p><b>-- Contour Map: %1 --</b><p> " infoText += QString( "<p><b>-- Contour Map: %1 --</b><p> "
"<b>Sample Count. Total:</b> %2 <b>Valid Results:</b> %3 <br>" "<b>Sample Count. Total:</b> %2 <b>Valid Results:</b> %3 <br>"

2
ApplicationCode/ProjectDataModel/Rim3dView.h
View File

@ -272,7 +272,7 @@ private:
// Pure private methods : Override viewer and comparison view // Pure private methods : Override viewer and comparison view
void setOverrideViewer( RiuViewer* overrideViewer ); void setOverrideViewer( RiuViewer* overrideViewer );
Rim3dView* prepareComparisonView(); Rim3dView* prepareComparisonView();
void restoreComparisonView(); void restoreComparisonView();

2
ApplicationCode/ProjectDataModel/RimEclipseContourMapView.cpp
View File

@ -222,7 +222,7 @@ void RimEclipseContourMapView::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiT
void RimEclipseContourMapView::onUpdateDisplayModelForCurrentTimeStep() void RimEclipseContourMapView::onUpdateDisplayModelForCurrentTimeStep()
{ {
static_cast<RimEclipsePropertyFilterCollection*>( nativePropertyFilterCollection() )->updateFromCurrentTimeStep(); static_cast<RimEclipsePropertyFilterCollection*>( nativePropertyFilterCollection() )->updateFromCurrentTimeStep();
m_contourMapProjection->clearGeometry(); m_contourMapProjection->clearGeometry();
updateGeometry(); updateGeometry();
} }

1
ApplicationCode/ProjectDataModel/RimEclipseGeometrySelectionItem.cpp
View File

@ -145,4 +145,3 @@ cvf::Vec3st RimEclipseGeometrySelectionItem::cellIJK() const
return IJK; return IJK;
} }

2
ApplicationCode/ProjectDataModel/RimEclipseGeometrySelectionItem.h
View File

@ -46,7 +46,7 @@ public:
RimEclipseCase* eclipseCase() const; RimEclipseCase* eclipseCase() const;
size_t gridIndex() const; size_t gridIndex() const;
size_t cellIndex() const; size_t cellIndex() const;
cvf::Vec3st cellIJK() const; cvf::Vec3st cellIJK() const;
private: private:
caf::PdmPtrField<RimEclipseCase*> m_eclipseCase; caf::PdmPtrField<RimEclipseCase*> m_eclipseCase;

4
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -1169,9 +1169,9 @@ void RimEclipseView::onUpdateLegends()
{ {
std::vector<RimLegendConfig*> legendConfs = this->legendConfigs(); std::vector<RimLegendConfig*> legendConfs = this->legendConfigs();
for (auto legendConf : legendConfs) for ( auto legendConf : legendConfs )
{ {
nativeOrOverrideViewer()->removeColorLegend(legendConf->titledOverlayFrame()); nativeOrOverrideViewer()->removeColorLegend( legendConf->titledOverlayFrame() );
} }
} }
} }

4
ApplicationCode/ProjectDataModel/RimGeoMechView.cpp
View File

@ -442,9 +442,9 @@ void RimGeoMechView::onUpdateLegends()
{ {
std::vector<RimLegendConfig*> legendConfs = this->legendConfigs(); std::vector<RimLegendConfig*> legendConfs = this->legendConfigs();
for (auto legendConf : legendConfs) for ( auto legendConf : legendConfs )
{ {
nativeOrOverrideViewer()->removeColorLegend(legendConf->titledOverlayFrame()); nativeOrOverrideViewer()->removeColorLegend( legendConf->titledOverlayFrame() );
} }
} }

6
ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.h
View File

@ -25,8 +25,8 @@
#include "cafPdmProxyValueField.h" #include "cafPdmProxyValueField.h"
#include "cafPdmPtrField.h" #include "cafPdmPtrField.h"
#include <memory>
#include "SummaryPlotCommands/RicSummaryPlotFeatureImpl.h" #include "SummaryPlotCommands/RicSummaryPlotFeatureImpl.h"
#include <memory>
class RigMainGrid; class RigMainGrid;
class RimEclipseCase; class RimEclipseCase;
@ -65,8 +65,8 @@ public:
RigGridCellResultAddress resultAddress(); RigGridCellResultAddress resultAddress();
QString quantityName() const; QString quantityName() const;
QString caseName() const; QString caseName() const;
RimCase* gridCase() const; RimCase* gridCase() const;
protected: protected:

2
ApplicationCode/ProjectDataModel/RimGridView.cpp
View File

@ -87,7 +87,7 @@ RimGridView::~RimGridView( void )
if ( proj && this->isMasterView() ) if ( proj && this->isMasterView() )
{ {
RimViewLinker* viewLinker = this->assosiatedViewLinker(); RimViewLinker* viewLinker = this->assosiatedViewLinker();
viewLinker->setMasterView(nullptr); viewLinker->setMasterView( nullptr );
delete proj->viewLinkerCollection->viewLinker(); delete proj->viewLinkerCollection->viewLinker();
proj->viewLinkerCollection->viewLinker = nullptr; proj->viewLinkerCollection->viewLinker = nullptr;

4
ApplicationCode/ProjectDataModel/RimIntersectionBox.cpp
View File

@ -313,9 +313,9 @@ void RimIntersectionBox::fieldChangedByUi( const caf::PdmFieldHandle* changedFie
Rim3dView* rimView = nullptr; Rim3dView* rimView = nullptr;
this->firstAncestorOrThisOfType( rimView ); this->firstAncestorOrThisOfType( rimView );
for (Rim3dView * mainView : rimView->viewsUsingThisAsComparisonView()) for ( Rim3dView* mainView : rimView->viewsUsingThisAsComparisonView() )
{ {
m_boxManipulator->registerInAdditionalViewer( mainView->viewer()); m_boxManipulator->registerInAdditionalViewer( mainView->viewer() );
} }
connect( m_boxManipulator, SIGNAL( notifyRedraw() ), this, SLOT( slotScheduleRedraw() ) ); connect( m_boxManipulator, SIGNAL( notifyRedraw() ), this, SLOT( slotScheduleRedraw() ) );

2
ApplicationCode/ProjectDataModel/RimOilField.cpp
View File

@ -177,7 +177,7 @@ QString RimOilField::uniqueShortNameForCase( RimSummaryCase* summaryCase )
} }
} }
int autoNumber = 0; int autoNumber = 0;
while ( !foundUnique ) while ( !foundUnique )
{ {

2
ApplicationCode/ProjectDataModel/RimProject.h
View File

@ -124,7 +124,7 @@ public:
std::vector<RimSummaryCaseCollection*> summaryGroups() const; std::vector<RimSummaryCaseCollection*> summaryGroups() const;
RimSummaryCaseMainCollection* firstSummaryCaseMainCollection() const; RimSummaryCaseMainCollection* firstSummaryCaseMainCollection() const;
void allViews(std::vector<Rim3dView*>& views) const; void allViews( std::vector<Rim3dView*>& views ) const;
void allVisibleViews( std::vector<Rim3dView*>& views ) const; void allVisibleViews( std::vector<Rim3dView*>& views ) const;
void allVisibleGridViews( std::vector<RimGridView*>& views ) const; void allVisibleGridViews( std::vector<RimGridView*>& views ) const;
void allNotLinkedViews( std::vector<RimGridView*>& views ); void allNotLinkedViews( std::vector<RimGridView*>& views );

18
ApplicationCode/ProjectDataModel/RimViewLinker.cpp
View File

@ -87,8 +87,8 @@ RimViewLinker::~RimViewLinker()
m_viewControllers.deleteAllChildObjects(); m_viewControllers.deleteAllChildObjects();
RimGridView* masterView = m_masterView; RimGridView* masterView = m_masterView;
m_masterView = nullptr; m_masterView = nullptr;
if (masterView) masterView->updateHolder(); if ( masterView ) masterView->updateHolder();
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -278,7 +278,7 @@ void RimViewLinker::allViewsForCameraSync( const RimGridView* source, std::vecto
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimViewLinker::updateDependentViews() void RimViewLinker::updateDependentViews()
{ {
if (m_viewControllers.empty()) return; if ( m_viewControllers.empty() ) return;
updateOverrides(); updateOverrides();
updateCellResult(); updateCellResult();
@ -308,7 +308,7 @@ QString RimViewLinker::displayNameForView( RimGridView* view )
void RimViewLinker::setMasterView( RimGridView* view ) void RimViewLinker::setMasterView( RimGridView* view )
{ {
RimViewController* previousViewController = nullptr; RimViewController* previousViewController = nullptr;
if (view) previousViewController = view->viewController(); if ( view ) previousViewController = view->viewController();
// Remove the view as dependent view // Remove the view as dependent view
if ( previousViewController ) if ( previousViewController )
@ -414,8 +414,8 @@ void RimViewLinker::updateUiNameAndIcon()
{ {
caf::QIconProvider iconProvider; caf::QIconProvider iconProvider;
RimViewLinker::findNameAndIconFromView( &m_name.v(), &iconProvider, m_masterView ); RimViewLinker::findNameAndIconFromView( &m_name.v(), &iconProvider, m_masterView );
if (m_masterView) m_masterView->updateHolder(); if ( m_masterView ) m_masterView->updateHolder();
setUiIcon( iconProvider ); setUiIcon( iconProvider );
} }
@ -644,7 +644,7 @@ void RimViewLinker::addViewControllers( caf::PdmUiTreeOrdering& uiTreeOrdering )
{ {
for ( const auto& viewController : m_viewControllers ) for ( const auto& viewController : m_viewControllers )
{ {
if (viewController) uiTreeOrdering.add( viewController ); if ( viewController ) uiTreeOrdering.add( viewController );
} }
} }
@ -679,11 +679,11 @@ void RimViewLinker::removeViewController( RimViewController* viewController )
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimGridView* RimViewLinker::firstControlledView() RimGridView* RimViewLinker::firstControlledView()
{ {
if (m_viewControllers.empty()) return nullptr; if ( m_viewControllers.empty() ) return nullptr;
return m_viewControllers[0]->managedView(); return m_viewControllers[0]->managedView();
} }

5
ApplicationCode/ProjectDataModel/RimViewLinker.h
View File

@ -92,7 +92,7 @@ public:
void updateCursorPosition( const RimGridView* sourceView, const cvf::Vec3d& domainCoord ); void updateCursorPosition( const RimGridView* sourceView, const cvf::Vec3d& domainCoord );
void notifyManagedViewChange(RimGridView* oldManagedView, RimGridView* newManagedView); void notifyManagedViewChange( RimGridView* oldManagedView, RimGridView* newManagedView );
protected: protected:
caf::PdmFieldHandle* userDescriptionField() override caf::PdmFieldHandle* userDescriptionField() override
@ -108,8 +108,7 @@ protected:
QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions, QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions,
bool* useOptionsOnly ) override; bool* useOptionsOnly ) override;
virtual void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
private: private:
static QString displayNameForView( RimGridView* view ); static QString displayNameForView( RimGridView* view );

2
ApplicationCode/ProjectDataModel/RimWellLogCurveCommonDataSource.cpp
View File

@ -758,7 +758,7 @@ QList<caf::PdmOptionItemInfo>
} }
} }
std::vector<RimWellLogExtractionCurve::TrajectoryType> trajectoryTypes = std::vector<RimWellLogExtractionCurve::TrajectoryType> trajectoryTypes =
{ RimWellLogExtractionCurve::WELL_PATH, RimWellLogExtractionCurve::SIMULATION_WELL }; {RimWellLogExtractionCurve::WELL_PATH, RimWellLogExtractionCurve::SIMULATION_WELL};
for ( RimWellLogExtractionCurve::TrajectoryType trajectoryType : trajectoryTypes ) for ( RimWellLogExtractionCurve::TrajectoryType trajectoryType : trajectoryTypes )
{ {
caf::PdmOptionItemInfo item( caf::AppEnum<RimWellLogExtractionCurve::TrajectoryType>::uiText( trajectoryType ), caf::PdmOptionItemInfo item( caf::AppEnum<RimWellLogExtractionCurve::TrajectoryType>::uiText( trajectoryType ),

4
ApplicationCode/ProjectDataModel/RimWellLogPlot.cpp
View File

@ -106,8 +106,8 @@ RimWellLogPlot::RimWellLogPlot()
m_nameConfig.uiCapability()->setUiTreeChildrenHidden( true ); m_nameConfig.uiCapability()->setUiTreeChildrenHidden( true );
m_nameConfig = new RimWellLogPlotNameConfig(); m_nameConfig = new RimWellLogPlotNameConfig();
m_availableDepthUnits = { RiaDefines::UNIT_METER, RiaDefines::UNIT_FEET }; m_availableDepthUnits = {RiaDefines::UNIT_METER, RiaDefines::UNIT_FEET};
m_availableDepthTypes = { MEASURED_DEPTH, TRUE_VERTICAL_DEPTH }; m_availableDepthTypes = {MEASURED_DEPTH, TRUE_VERTICAL_DEPTH};
m_minAvailableDepth = HUGE_VAL; m_minAvailableDepth = HUGE_VAL;
m_maxAvailableDepth = -HUGE_VAL; m_maxAvailableDepth = -HUGE_VAL;

46
ApplicationCode/ProjectDataModel/RimWellLogTrack.cpp
View File

@ -2253,7 +2253,7 @@ void RimWellLogTrack::updateCurveDataRegionsOnPlot()
caf::ColorTable colorTable( RimRegularLegendConfig::colorArrayFromColorType( m_colorShadingPalette() ) ); caf::ColorTable colorTable( RimRegularLegendConfig::colorArrayFromColorType( m_colorShadingPalette() ) );
std::vector<QString> sourceNames = std::vector<QString> sourceNames =
{ "", "PP=Grid", "PP=Las-File", "PP=Element Property Table", "", "PP=Hydrostatic" }; {"", "PP=Grid", "PP=Las-File", "PP=Element Property Table", "", "PP=Hydrostatic"};
curveData.data = ppValues; curveData.data = ppValues;
std::vector<QString> sourceNamesToPlot; std::vector<QString> sourceNamesToPlot;
@ -2277,12 +2277,12 @@ void RimWellLogTrack::updateCurveDataRegionsOnPlot()
caf::ColorTable colorTable( RimRegularLegendConfig::colorArrayFromColorType( m_colorShadingPalette() ) ); caf::ColorTable colorTable( RimRegularLegendConfig::colorArrayFromColorType( m_colorShadingPalette() ) );
std::vector<QString> sourceNames = std::vector<QString> sourceNames =
{ "", {"",
"", "",
"Poisson=Las-File", "Poisson=Las-File",
"Poisson=Element Property Table", "Poisson=Element Property Table",
QString( "Poisson=%1" ).arg( wellBoreStabilityPlot->userDefinedPoissonRatio() ), QString( "Poisson=%1" ).arg( wellBoreStabilityPlot->userDefinedPoissonRatio() ),
"" }; ""};
curveData.data = poissonValues; curveData.data = poissonValues;
std::vector<QString> sourceNamesToPlot; std::vector<QString> sourceNamesToPlot;
@ -2305,12 +2305,12 @@ void RimWellLogTrack::updateCurveDataRegionsOnPlot()
{ {
caf::ColorTable colorTable( RimRegularLegendConfig::colorArrayFromColorType( m_colorShadingPalette() ) ); caf::ColorTable colorTable( RimRegularLegendConfig::colorArrayFromColorType( m_colorShadingPalette() ) );
std::vector<QString> sourceNames = { "", std::vector<QString> sourceNames = {"",
"", "",
"UCS=Las-File", "UCS=Las-File",
"UCS=Element Property Table", "UCS=Element Property Table",
QString( "UCS=%1" ).arg( wellBoreStabilityPlot->userDefinedUcs() ), QString( "UCS=%1" ).arg( wellBoreStabilityPlot->userDefinedUcs() ),
"" }; ""};
curveData.data = ucsValues; curveData.data = ucsValues;
@ -2380,16 +2380,16 @@ void RimWellLogTrack::updateWellPathAttributesOnPlot()
} }
} }
const std::map<RiaDefines::WellPathComponentType, int> sortIndices = { { RiaDefines::WELL_PATH, 0 }, const std::map<RiaDefines::WellPathComponentType, int> sortIndices = {{RiaDefines::WELL_PATH, 0},
{ RiaDefines::CASING, 1 }, {RiaDefines::CASING, 1},
{ RiaDefines::LINER, 2 }, {RiaDefines::LINER, 2},
{ RiaDefines::PERFORATION_INTERVAL, 3 }, {RiaDefines::PERFORATION_INTERVAL, 3},
{ RiaDefines::FISHBONES, 4 }, {RiaDefines::FISHBONES, 4},
{ RiaDefines::FRACTURE, 5 }, {RiaDefines::FRACTURE, 5},
{ RiaDefines::PACKER, 6 }, {RiaDefines::PACKER, 6},
{ RiaDefines::ICD, 7 }, {RiaDefines::ICD, 7},
{ RiaDefines::AICD, 8 }, {RiaDefines::AICD, 8},
{ RiaDefines::ICV, 9 } }; {RiaDefines::ICV, 9}};
std::stable_sort( allWellPathComponents.begin(), std::stable_sort( allWellPathComponents.begin(),
allWellPathComponents.end(), allWellPathComponents.end(),

32
ApplicationCode/ProjectDataModel/RimWellPathAttribute.cpp
View File

@ -160,22 +160,22 @@ std::set<double> RimWellPathAttribute::supportedDiameters( RiaDefines::WellPathC
std::set<double> values; std::set<double> values;
if ( type == RiaDefines::CASING ) if ( type == RiaDefines::CASING )
{ {
values = { MAX_DIAMETER_IN_INCHES, values = {MAX_DIAMETER_IN_INCHES,
26.0, 26.0,
22.0, 22.0,
20.0, 20.0,
18.0 + 5.0 / 8.0, 18.0 + 5.0 / 8.0,
16.0, 16.0,
14.0, 14.0,
13.0 + 3.0 / 8.0, 13.0 + 3.0 / 8.0,
10.0 + 3.0 / 4.0, 10.0 + 3.0 / 4.0,
9.0 + 7.0 / 8.0, 9.0 + 7.0 / 8.0,
9.0 + 5.0 / 8.0, 9.0 + 5.0 / 8.0,
MIN_DIAMETER_IN_INCHES }; MIN_DIAMETER_IN_INCHES};
} }
else else
{ {
values = { 9.0 + 7.0 / 8.0, 9.0 + 5.0 / 8.0, 7.0, 5.5, 5.0, 4.5, 3.5 }; values = {9.0 + 7.0 / 8.0, 9.0 + 5.0 / 8.0, 7.0, 5.5, 5.0, 4.5, 3.5};
} }
return values; return values;
} }
@ -197,9 +197,9 @@ QList<caf::PdmOptionItemInfo> RimWellPathAttribute::calculateValueOptions( const
QList<caf::PdmOptionItemInfo> options; QList<caf::PdmOptionItemInfo> options;
if ( fieldNeedingOptions == &m_type ) if ( fieldNeedingOptions == &m_type )
{ {
std::set<RiaDefines::WellPathComponentType> supportedTypes = { RiaDefines::CASING, std::set<RiaDefines::WellPathComponentType> supportedTypes = {RiaDefines::CASING,
RiaDefines::LINER, RiaDefines::LINER,
RiaDefines::PACKER }; RiaDefines::PACKER};
for ( RiaDefines::WellPathComponentType type : supportedTypes ) for ( RiaDefines::WellPathComponentType type : supportedTypes )
{ {
options.push_back( caf::PdmOptionItemInfo( CompletionTypeEnum::uiText( type ), type ) ); options.push_back( caf::PdmOptionItemInfo( CompletionTypeEnum::uiText( type ), type ) );

2
ApplicationCode/ProjectDataModel/Summary/RimCalculatedSummaryCase.cpp
View File

@ -31,7 +31,7 @@ RimCalculatedSummaryCase::RimCalculatedSummaryCase()
CAF_PDM_InitObject( "Calculated", ":/SummaryCase48x48.png", "", "" ); CAF_PDM_InitObject( "Calculated", ":/SummaryCase48x48.png", "", "" );
m_calculatedCurveReader = nullptr; m_calculatedCurveReader = nullptr;
m_shortName = "Calculated"; m_shortName = "Calculated";
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

2
ApplicationCode/ProjectDataModel/Summary/RimEnsembleCurveSet.cpp
View File

@ -633,7 +633,7 @@ void RimEnsembleCurveSet::defineUiOrdering( QString uiConfigName, caf::PdmUiOrde
caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup( "Summary Vector Y" ); caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup( "Summary Vector Y" );
curveDataGroup->add( &m_yValuesSummaryCaseCollection ); curveDataGroup->add( &m_yValuesSummaryCaseCollection );
curveDataGroup->add( &m_yValuesSummaryAddressUiField ); curveDataGroup->add( &m_yValuesSummaryAddressUiField );
curveDataGroup->add( &m_yPushButtonSelectSummaryAddress, { false, 1, 0 } ); curveDataGroup->add( &m_yPushButtonSelectSummaryAddress, {false, 1, 0} );
curveDataGroup->add( &m_plotAxis ); curveDataGroup->add( &m_plotAxis );
} }

14
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurve.cpp
View File

@ -637,10 +637,10 @@ void RimSummaryCurve::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering
QString curveDataGroupName = "Summary Vector"; QString curveDataGroupName = "Summary Vector";
if ( isCrossPlotCurve() ) curveDataGroupName += " Y"; if ( isCrossPlotCurve() ) curveDataGroupName += " Y";
caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroupWithKeyword( curveDataGroupName, "Summary Vector Y" ); caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroupWithKeyword( curveDataGroupName, "Summary Vector Y" );
curveDataGroup->add( &m_yValuesSummaryCase, { true, 3, 1 } ); curveDataGroup->add( &m_yValuesSummaryCase, {true, 3, 1} );
curveDataGroup->add( &m_yValuesSummaryAddressUiField, { true, 2, 1 } ); curveDataGroup->add( &m_yValuesSummaryAddressUiField, {true, 2, 1} );
curveDataGroup->add( &m_yPushButtonSelectSummaryAddress, { false, 1, 0 } ); curveDataGroup->add( &m_yPushButtonSelectSummaryAddress, {false, 1, 0} );
curveDataGroup->add( &m_plotAxis, { true, 3, 1 } ); curveDataGroup->add( &m_plotAxis, {true, 3, 1} );
if ( isCrossPlotCurve() ) if ( isCrossPlotCurve() )
m_showErrorBars = false; m_showErrorBars = false;
@ -651,9 +651,9 @@ void RimSummaryCurve::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering
if ( isCrossPlotCurve() ) if ( isCrossPlotCurve() )
{ {
caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup( "Summary Vector X" ); caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup( "Summary Vector X" );
curveDataGroup->add( &m_xValuesSummaryCase, { true, 3, 1 } ); curveDataGroup->add( &m_xValuesSummaryCase, {true, 3, 1} );
curveDataGroup->add( &m_xValuesSummaryAddressUiField, { true, 2, 1 } ); curveDataGroup->add( &m_xValuesSummaryAddressUiField, {true, 2, 1} );
curveDataGroup->add( &m_xPushButtonSelectSummaryAddress, { false, 1, 0 } ); curveDataGroup->add( &m_xPushButtonSelectSummaryAddress, {false, 1, 0} );
} }
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup( "Appearance" ); caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup( "Appearance" );

2
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveAppearanceCalculator.cpp
View File

@ -539,7 +539,7 @@ RiuQwtSymbol::PointSymbolEnum RimSummaryCurveAppearanceCalculator::cycledSymbol(
int RimSummaryCurveAppearanceCalculator::cycledLineThickness( int index ) int RimSummaryCurveAppearanceCalculator::cycledLineThickness( int index )
{ {
static const int thicknessCount = 3; static const int thicknessCount = 3;
static const int thicknesses[] = { 1, 3, 5 }; static const int thicknesses[] = {1, 3, 5};
if ( index < 0 ) return 1; if ( index < 0 ) return 1;
return ( thicknesses[( index ) % thicknessCount] ); return ( thicknesses[( index ) % thicknessCount] );

2
ApplicationCode/ProjectDataModel/Summary/RimSummaryCurveFilter.h
View File

@ -62,7 +62,7 @@ private:
caf::PdmField<bool> m_showLegend; caf::PdmField<bool> m_showLegend;
// Filter fields // Filter fields
caf::PdmChildField<RimSummaryFilter_OBSOLETE*> m_summaryFilter; caf::PdmChildField<RimSummaryFilter_OBSOLETE*> m_summaryFilter;
caf::PdmField<std::vector<RifEclipseSummaryAddress>> m_uiFilterResultMultiSelection; caf::PdmField<std::vector<RifEclipseSummaryAddress>> m_uiFilterResultMultiSelection;
caf::PdmChildField<RimSummaryCurveAutoName*> m_curveNameConfig; caf::PdmChildField<RimSummaryCurveAutoName*> m_curveNameConfig;

12
ApplicationCode/ProjectDataModel/Summary/RimSummaryFilter.cpp
View File

@ -36,7 +36,9 @@ void caf::AppEnum<RimSummaryFilter_OBSOLETE::SummaryFilterType>::setUp()
addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_REGION, "SUM_FILTER_REGION", "Region" ); addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_REGION, "SUM_FILTER_REGION", "Region" );
addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_REGION_2_REGION, "SUM_FILTER_REGION_2_REGION", "Region-Region" ); addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_REGION_2_REGION, "SUM_FILTER_REGION_2_REGION", "Region-Region" );
addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_WELL_LGR, "SUM_FILTER_WELL_LGR", "Lgr-Well" ); addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_WELL_LGR, "SUM_FILTER_WELL_LGR", "Lgr-Well" );
addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_WELL_COMPLETION_LGR, "SUM_FILTER_WELL_COMPLETION_LGR", "Lgr-Completion" ); addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_WELL_COMPLETION_LGR,
"SUM_FILTER_WELL_COMPLETION_LGR",
"Lgr-Completion" );
addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_BLOCK_LGR, "SUM_FILTER_BLOCK_LGR", "Lgr-Block" ); addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_BLOCK_LGR, "SUM_FILTER_BLOCK_LGR", "Lgr-Block" );
addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_MISC, "SUM_FILTER_MISC", "Misc" ); addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_MISC, "SUM_FILTER_MISC", "Misc" );
addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_AQUIFER, "SUM_FILTER_AQUIFER", "Aquifer" ); addItem( RimSummaryFilter_OBSOLETE::SUM_FILTER_AQUIFER, "SUM_FILTER_AQUIFER", "Aquifer" );
@ -325,8 +327,8 @@ bool RimSummaryFilter_OBSOLETE::isIncludedByFilter( const RifEclipseSummaryAddre
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimSummaryFilter_OBSOLETE::isSumVarTypeMatchingFilterType( SummaryFilterType sumFilterType, bool RimSummaryFilter_OBSOLETE::isSumVarTypeMatchingFilterType( SummaryFilterType sumFilterType,
RifEclipseSummaryAddress::SummaryVarCategory sumVarType ) RifEclipseSummaryAddress::SummaryVarCategory sumVarType )
{ {
if ( sumVarType == RifEclipseSummaryAddress::SUMMARY_INVALID ) return false; if ( sumVarType == RifEclipseSummaryAddress::SUMMARY_INVALID ) return false;
if ( sumFilterType == SUM_FILTER_ANY || sumFilterType == SUM_FILTER_VAR_STRING ) return true; if ( sumFilterType == SUM_FILTER_ANY || sumFilterType == SUM_FILTER_VAR_STRING ) return true;
@ -505,8 +507,8 @@ void RimSummaryFilter_OBSOLETE::defineUiOrdering( QString uiConfigName, caf::Pdm
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimSummaryFilter_OBSOLETE::fieldChangedByUi( const caf::PdmFieldHandle* changedField, void RimSummaryFilter_OBSOLETE::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
const QVariant& oldValue, const QVariant& oldValue,
const QVariant& newValue ) const QVariant& newValue )
{ {
caf::PdmObject* parent = dynamic_cast<caf::PdmObject*>( this->parentField()->ownerObject() ); caf::PdmObject* parent = dynamic_cast<caf::PdmObject*>( this->parentField()->ownerObject() );

20
ApplicationCode/ProjectDataModel/Summary/RimSummaryPlot.cpp
View File

@ -331,7 +331,7 @@ QString RimSummaryPlot::asciiDataForSummaryPlotExport( DateTimePeriod resampling
populateTimeHistoryCurvesData( m_gridTimeHistoryCurves.childObjects(), &timeHistoryCurvesData ); populateTimeHistoryCurvesData( m_gridTimeHistoryCurves.childObjects(), &timeHistoryCurvesData );
// Export observed data // Export observed data
appendToExportData( out, { summaryCurvesObsData }, showTimeAsLongString ); appendToExportData( out, {summaryCurvesObsData}, showTimeAsLongString );
std::vector<CurvesData> exportData( 2 ); std::vector<CurvesData> exportData( 2 );
@ -353,7 +353,7 @@ QString RimSummaryPlot::asciiDataForSummaryPlotExport( DateTimePeriod resampling
CurvesData asciiCurvesData; CurvesData asciiCurvesData;
populateAsciiDataCurvesData( m_asciiDataCurves.childObjects(), &asciiCurvesData ); populateAsciiDataCurvesData( m_asciiDataCurves.childObjects(), &asciiCurvesData );
appendToExportData( out, { asciiCurvesData }, showTimeAsLongString ); appendToExportData( out, {asciiCurvesData}, showTimeAsLongString );
} }
return out; return out;
@ -1176,7 +1176,7 @@ void RimSummaryPlot::addCurveNoUpdate( RimSummaryCurve* curve )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimSummaryPlot::deleteCurve( RimSummaryCurve* curve ) void RimSummaryPlot::deleteCurve( RimSummaryCurve* curve )
{ {
deleteCurves( { curve } ); deleteCurves( {curve} );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -1497,7 +1497,7 @@ void RimSummaryPlot::updateZoomFromQwt()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::set<RimPlotAxisPropertiesInterface*> RimSummaryPlot::allPlotAxes() const std::set<RimPlotAxisPropertiesInterface*> RimSummaryPlot::allPlotAxes() const
{ {
return { m_timeAxisProperties, m_bottomAxisProperties, m_leftYAxisProperties, m_rightYAxisProperties }; return {m_timeAxisProperties, m_bottomAxisProperties, m_leftYAxisProperties, m_rightYAxisProperties};
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -2097,13 +2097,13 @@ void populateTimeHistoryCurvesData( std::vector<RimGridTimeHistoryCurve*> curves
if ( curveCaseName == curvesData->caseNames[i] ) casePosInList = i; if ( curveCaseName == curvesData->caseNames[i] ) casePosInList = i;
} }
CurveData curveData = { curve->curveExportDescription(), RifEclipseSummaryAddress(), curve->yValues() }; CurveData curveData = {curve->curveExportDescription(), RifEclipseSummaryAddress(), curve->yValues()};
if ( casePosInList == cvf::UNDEFINED_SIZE_T ) if ( casePosInList == cvf::UNDEFINED_SIZE_T )
{ {
curvesData->caseNames.push_back( curveCaseName ); curvesData->caseNames.push_back( curveCaseName );
curvesData->timeSteps.push_back( curve->timeStepValues() ); curvesData->timeSteps.push_back( curve->timeStepValues() );
curvesData->allCurveData.push_back( std::vector<CurveData>( { curveData } ) ); curvesData->allCurveData.push_back( std::vector<CurveData>( {curveData} ) );
} }
else else
{ {
@ -2129,13 +2129,13 @@ void populateAsciiDataCurvesData( std::vector<RimAsciiDataCurve*> curves, Curves
size_t casePosInList = cvf::UNDEFINED_SIZE_T; size_t casePosInList = cvf::UNDEFINED_SIZE_T;
CurveData curveData = { curve->curveExportDescription(), RifEclipseSummaryAddress(), curve->yValues() }; CurveData curveData = {curve->curveExportDescription(), RifEclipseSummaryAddress(), curve->yValues()};
if ( casePosInList == cvf::UNDEFINED_SIZE_T ) if ( casePosInList == cvf::UNDEFINED_SIZE_T )
{ {
curvesData->caseNames.push_back( "" ); curvesData->caseNames.push_back( "" );
curvesData->timeSteps.push_back( curve->timeSteps() ); curvesData->timeSteps.push_back( curve->timeSteps() );
curvesData->allCurveData.push_back( std::vector<CurveData>( { curveData } ) ); curvesData->allCurveData.push_back( std::vector<CurveData>( {curveData} ) );
} }
else else
{ {
@ -2171,7 +2171,7 @@ void populateSummaryCurvesData( std::vector<RimSummaryCurve*> curves, SummaryCur
if ( curveCaseName == curvesData->caseNames[i] ) casePosInList = i; if ( curveCaseName == curvesData->caseNames[i] ) casePosInList = i;
} }
CurveData curveData = { curve->curveExportDescription(), curve->summaryAddressY(), curve->valuesY() }; CurveData curveData = {curve->curveExportDescription(), curve->summaryAddressY(), curve->valuesY()};
CurveData errorCurveData; CurveData errorCurveData;
// Error data // Error data
@ -2187,7 +2187,7 @@ void populateSummaryCurvesData( std::vector<RimSummaryCurve*> curves, SummaryCur
if ( casePosInList == cvf::UNDEFINED_SIZE_T ) if ( casePosInList == cvf::UNDEFINED_SIZE_T )
{ {
auto curveDataList = std::vector<CurveData>( { curveData } ); auto curveDataList = std::vector<CurveData>( {curveData} );
if ( hasErrorData ) curveDataList.push_back( errorCurveData ); if ( hasErrorData ) curveDataList.push_back( errorCurveData );
curvesData->caseNames.push_back( curveCaseName ); curvesData->caseNames.push_back( curveCaseName );

24
ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp
View File

@ -1117,12 +1117,12 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
} }
else if ( resVarAddr.m_resultCatType == RiaDefines::UNDEFINED ) else if ( resVarAddr.m_resultCatType == RiaDefines::UNDEFINED )
{ {
std::vector<RiaDefines::ResultCatType> searchOrder = { RiaDefines::STATIC_NATIVE, std::vector<RiaDefines::ResultCatType> searchOrder = {RiaDefines::STATIC_NATIVE,
RiaDefines::DYNAMIC_NATIVE, RiaDefines::DYNAMIC_NATIVE,
RiaDefines::SOURSIMRL, RiaDefines::SOURSIMRL,
RiaDefines::GENERATED, RiaDefines::GENERATED,
RiaDefines::INPUT_PROPERTY, RiaDefines::INPUT_PROPERTY,
RiaDefines::FORMATION_NAMES }; RiaDefines::FORMATION_NAMES};
size_t scalarResultIndex = this->findOrLoadKnownScalarResultByResultTypeOrder( resVarAddr, searchOrder ); size_t scalarResultIndex = this->findOrLoadKnownScalarResultByResultTypeOrder( resVarAddr, searchOrder );
@ -1370,12 +1370,12 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
size_t RigCaseCellResultsData::findOrLoadKnownScalarResultByResultTypeOrder( size_t RigCaseCellResultsData::findOrLoadKnownScalarResultByResultTypeOrder(
const RigEclipseResultAddress& resVarAddr, const std::vector<RiaDefines::ResultCatType>& resultCategorySearchOrder ) const RigEclipseResultAddress& resVarAddr, const std::vector<RiaDefines::ResultCatType>& resultCategorySearchOrder )
{ {
std::set<RiaDefines::ResultCatType> otherResultTypesToSearch = { RiaDefines::STATIC_NATIVE, std::set<RiaDefines::ResultCatType> otherResultTypesToSearch = {RiaDefines::STATIC_NATIVE,
RiaDefines::DYNAMIC_NATIVE, RiaDefines::DYNAMIC_NATIVE,
RiaDefines::SOURSIMRL, RiaDefines::SOURSIMRL,
RiaDefines::INPUT_PROPERTY, RiaDefines::INPUT_PROPERTY,
RiaDefines::GENERATED, RiaDefines::GENERATED,
RiaDefines::FORMATION_NAMES }; RiaDefines::FORMATION_NAMES};
for ( const auto& resultType : resultCategorySearchOrder ) for ( const auto& resultType : resultCategorySearchOrder )
{ {

8
ApplicationCode/ReservoirDataModel/RigCellGeometryTools.cpp
View File

@ -97,14 +97,14 @@ bool RigCellGeometryTools::estimateHexOverlapWithBoundingBox( const std::array<c
std::array<cvf::Vec3d, 8> overlapCorners = hexCorners; std::array<cvf::Vec3d, 8> overlapCorners = hexCorners;
std::vector<cvf::Vec3d> uniqueTopPoints = { hexCorners[0], hexCorners[1], hexCorners[2], hexCorners[3] }; std::vector<cvf::Vec3d> uniqueTopPoints = {hexCorners[0], hexCorners[1], hexCorners[2], hexCorners[3]};
uniqueTopPoints.erase( std::unique( uniqueTopPoints.begin(), uniqueTopPoints.end() ), uniqueTopPoints.end() ); uniqueTopPoints.erase( std::unique( uniqueTopPoints.begin(), uniqueTopPoints.end() ), uniqueTopPoints.end() );
if ( uniqueTopPoints.size() < 3 ) return false; if ( uniqueTopPoints.size() < 3 ) return false;
cvf::Plane topPlane; cvf::Plane topPlane;
if ( !topPlane.setFromPoints( uniqueTopPoints[0], uniqueTopPoints[1], uniqueTopPoints[2] ) ) return false; if ( !topPlane.setFromPoints( uniqueTopPoints[0], uniqueTopPoints[1], uniqueTopPoints[2] ) ) return false;
std::vector<cvf::Vec3d> uniqueBottomPoints = { hexCorners[4], hexCorners[5], hexCorners[6], hexCorners[7] }; std::vector<cvf::Vec3d> uniqueBottomPoints = {hexCorners[4], hexCorners[5], hexCorners[6], hexCorners[7]};
uniqueBottomPoints.erase( std::unique( uniqueBottomPoints.begin(), uniqueBottomPoints.end() ), uniqueBottomPoints.erase( std::unique( uniqueBottomPoints.begin(), uniqueBottomPoints.end() ),
uniqueBottomPoints.end() ); uniqueBottomPoints.end() );
if ( uniqueBottomPoints.size() < 3 ) return false; if ( uniqueBottomPoints.size() < 3 ) return false;
@ -256,7 +256,7 @@ void RigCellGeometryTools::simplifyPolygon( std::vector<cvf::Vec3d>* vertices, d
} }
else else
{ {
std::vector<cvf::Vec3d> newVertices = { vertices->front(), vertices->back() }; std::vector<cvf::Vec3d> newVertices = {vertices->front(), vertices->back()};
*vertices = newVertices; *vertices = newVertices;
} }
} }
@ -654,7 +654,7 @@ std::pair<cvf::Vec3d, cvf::Vec3d> RigCellGeometryTools::getLineThroughBoundingBo
} }
std::pair<cvf::Vec3d, cvf::Vec3d> line; std::pair<cvf::Vec3d, cvf::Vec3d> line;
line = { startPoint, endPoint }; line = {startPoint, endPoint};
return line; return line;
} }

8
ApplicationCode/ReservoirDataModel/RigGeoMechWellLogExtractor.cpp
View File

@ -98,7 +98,7 @@ void RigGeoMechWellLogExtractor::performCurveDataSmoothing( int
if ( !mds->empty() && !values->empty() ) if ( !mds->empty() && !values->empty() )
{ {
std::vector<std::vector<double>*> dependentValues = { tvds, &interfaceShValuesDbl, &interfacePorePressuresDbl }; std::vector<std::vector<double>*> dependentValues = {tvds, &interfaceShValuesDbl, &interfacePorePressuresDbl};
std::vector<unsigned char> smoothOrFilterSegments = determineFilteringOrSmoothing( interfacePorePressuresDbl ); std::vector<unsigned char> smoothOrFilterSegments = determineFilteringOrSmoothing( interfacePorePressuresDbl );
filterShortSegments( mds, values, &smoothOrFilterSegments, dependentValues ); filterShortSegments( mds, values, &smoothOrFilterSegments, dependentValues );
@ -625,7 +625,7 @@ void RigGeoMechWellLogExtractor::setWellLogMdAndPoissonRatio( const std::vector<
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::set<RigGeoMechWellLogExtractor::WbsParameterSource> RigGeoMechWellLogExtractor::supportedSourcesForPorePressure() std::set<RigGeoMechWellLogExtractor::WbsParameterSource> RigGeoMechWellLogExtractor::supportedSourcesForPorePressure()
{ {
return { AUTO, GRID, LAS_FILE, ELEMENT_PROPERTY_TABLE, HYDROSTATIC_PP }; return {AUTO, GRID, LAS_FILE, ELEMENT_PROPERTY_TABLE, HYDROSTATIC_PP};
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -633,7 +633,7 @@ std::set<RigGeoMechWellLogExtractor::WbsParameterSource> RigGeoMechWellLogExtrac
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::set<RigGeoMechWellLogExtractor::WbsParameterSource> RigGeoMechWellLogExtractor::supportedSourcesForPoissonRatio() std::set<RigGeoMechWellLogExtractor::WbsParameterSource> RigGeoMechWellLogExtractor::supportedSourcesForPoissonRatio()
{ {
return { AUTO, LAS_FILE, ELEMENT_PROPERTY_TABLE, USER_DEFINED }; return {AUTO, LAS_FILE, ELEMENT_PROPERTY_TABLE, USER_DEFINED};
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -641,7 +641,7 @@ std::set<RigGeoMechWellLogExtractor::WbsParameterSource> RigGeoMechWellLogExtrac
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::set<RigGeoMechWellLogExtractor::WbsParameterSource> RigGeoMechWellLogExtractor::supportedSourcesForUcs() std::set<RigGeoMechWellLogExtractor::WbsParameterSource> RigGeoMechWellLogExtractor::supportedSourcesForUcs()
{ {
return { AUTO, LAS_FILE, ELEMENT_PROPERTY_TABLE, USER_DEFINED }; return {AUTO, LAS_FILE, ELEMENT_PROPERTY_TABLE, USER_DEFINED};
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

8
ApplicationCode/ReservoirDataModel/RigMainGrid.cpp
View File

@ -856,10 +856,10 @@ void RigMainGrid::setDualPorosity( bool enable )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
std::array<double, 6> RigMainGrid::defaultMapAxes() std::array<double, 6> RigMainGrid::defaultMapAxes()
{ {
const double origin[2] = { 0.0, 0.0 }; const double origin[2] = {0.0, 0.0};
const double xPoint[2] = { 1.0, 0.0 }; const double xPoint[2] = {1.0, 0.0};
const double yPoint[2] = { 0.0, 1.0 }; const double yPoint[2] = {0.0, 1.0};
// Order (see Elipse Reference Manual for keyword MAPAXES): Y_x, Y_y, O_x, O_y, X_x, X_y // Order (see Elipse Reference Manual for keyword MAPAXES): Y_x, Y_y, O_x, O_y, X_x, X_y
return { yPoint[0], yPoint[1], origin[0], origin[1], xPoint[0], xPoint[1] }; return {yPoint[0], yPoint[1], origin[0], origin[1], xPoint[0], xPoint[1]};
} }

10
ApplicationCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp
View File

@ -887,9 +887,9 @@ private:
else // if ( endToGrow > 1 ) else // if ( endToGrow > 1 )
{ {
m_branchLines.push_back( std::make_pair( false, m_branchLines.push_back( std::make_pair( false,
std::deque<size_t>{ branchList.front(), std::deque<size_t>{branchList.front(),
cellWithNeighborsPair.first, cellWithNeighborsPair.first,
neighbour } ) ); neighbour} ) );
auto newBranchLineIt = std::prev( m_branchLines.end() ); auto newBranchLineIt = std::prev( m_branchLines.end() );
growBranchListEnd( newBranchLineIt ); growBranchListEnd( newBranchLineIt );
if ( newBranchLineIt->second.size() == 3 ) if ( newBranchLineIt->second.size() == 3 )
@ -987,11 +987,11 @@ private:
{ {
if ( prevCell == cvf::UNDEFINED_SIZE_T ) if ( prevCell == cvf::UNDEFINED_SIZE_T )
{ {
m_branchLines.push_back( std::make_pair( false, std::deque<size_t>{ startCell, nb } ) ); m_branchLines.push_back( std::make_pair( false, std::deque<size_t>{startCell, nb} ) );
} }
else else
{ {
m_branchLines.push_back( std::make_pair( false, std::deque<size_t>{ prevCell, startCell, nb } ) ); m_branchLines.push_back( std::make_pair( false, std::deque<size_t>{prevCell, startCell, nb} ) );
} }
m_unusedWellCellIndices.erase( nb ); m_unusedWellCellIndices.erase( nb );

2
ApplicationCode/UserInterface/RiuCadNavigation.cpp
View File

@ -55,7 +55,7 @@ bool RiuCadNavigation::handleInputEvent( QInputEvent* inputEvent )
if ( me->button() == Qt::MidButton && me->modifiers() == Qt::NoModifier && isRotationEnabled() ) if ( me->button() == Qt::MidButton && me->modifiers() == Qt::NoModifier && isRotationEnabled() )
{ {
this->pickAndSetPointOfInterest(me->x(), me->y()); this->pickAndSetPointOfInterest( me->x(), me->y() );
m_trackball->startNavigation( cvf::ManipulatorTrackball::ROTATE, translatedMousePosX, translatedMousePosY ); m_trackball->startNavigation( cvf::ManipulatorTrackball::ROTATE, translatedMousePosX, translatedMousePosY );
m_isNavigating = true; m_isNavigating = true;

3
ApplicationCode/UserInterface/RiuComparisonViewMover.cpp
View File

@ -68,8 +68,7 @@ bool RiuComparisonViewMover::eventFilter( QObject* watched, QEvent* event )
m_viewer->setComparisonViewVisibleNormalizedRect( m_viewer->setComparisonViewVisibleNormalizedRect(
cvf::Rectf( normMousePos.x(), cvf::Rectf( normMousePos.x(),
orgCompViewWindow.min().y(), orgCompViewWindow.min().y(),
( orgCompViewWindow.min().x() + orgCompViewWindow.width() ) - ( orgCompViewWindow.min().x() + orgCompViewWindow.width() ) - normMousePos.x(),
normMousePos.x(),
orgCompViewWindow.height() ) ); orgCompViewWindow.height() ) );
return true; return true;

2
ApplicationCode/UserInterface/RiuGeoQuestNavigation.cpp
View File

@ -55,7 +55,7 @@ bool RiuGeoQuestNavigation::handleInputEvent( QInputEvent* inputEvent )
if ( me->button() == Qt::LeftButton && isRotationEnabled() ) if ( me->button() == Qt::LeftButton && isRotationEnabled() )
{ {
this->pickAndSetPointOfInterest(me->x(), me->y()); this->pickAndSetPointOfInterest( me->x(), me->y() );
m_trackball->startNavigation( cvf::ManipulatorTrackball::ROTATE, translatedMousePosX, translatedMousePosY ); m_trackball->startNavigation( cvf::ManipulatorTrackball::ROTATE, translatedMousePosX, translatedMousePosY );
m_isNavigating = true; m_isNavigating = true;

2
ApplicationCode/UserInterface/RiuGridPlotWindow.cpp
View File

@ -482,7 +482,7 @@ void RiuGridPlotWindow::dropEvent( QDropEvent* event )
if ( insertAfter != plotToMove ) if ( insertAfter != plotToMove )
{ {
m_plotDefinition->movePlotsToThis( { plotToMove }, insertAfter ); m_plotDefinition->movePlotsToThis( {plotToMove}, insertAfter );
} }
} }
} }

2
ApplicationCode/UserInterface/RiuPlotMainWindow.cpp
View File

@ -574,7 +574,7 @@ void RiuPlotMainWindow::updateGridPlotWindowToolBar()
RimGridPlotWindow* plotWindow = dynamic_cast<RimGridPlotWindow*>( m_activePlotViewWindow.p() ); RimGridPlotWindow* plotWindow = dynamic_cast<RimGridPlotWindow*>( m_activePlotViewWindow.p() );
if ( plotWindow ) if ( plotWindow )
{ {
std::vector<caf::PdmFieldHandle*> toolBarFields = { plotWindow->columnCountField() }; std::vector<caf::PdmFieldHandle*> toolBarFields = {plotWindow->columnCountField()};
m_gridPlotWindowToolBarEditor->setFields( toolBarFields ); m_gridPlotWindowToolBarEditor->setFields( toolBarFields );
m_gridPlotWindowToolBarEditor->updateUi(); m_gridPlotWindowToolBarEditor->updateUi();
m_gridPlotWindowToolBarEditor->show(); m_gridPlotWindowToolBarEditor->show();

18
ApplicationCode/UserInterface/RiuQwtPlotTools.cpp
View File

@ -75,7 +75,7 @@ void RiuQwtPlotTools::setCommonPlotBehaviour( QwtPlot* plot )
plot->setAxisFont( QwtPlot::yRight, axisFont ); plot->setAxisFont( QwtPlot::yRight, axisFont );
// Axis title font // Axis title font
std::vector<QwtPlot::Axis> axes = { QwtPlot::xBottom, QwtPlot::xTop, QwtPlot::yLeft, QwtPlot::yRight }; std::vector<QwtPlot::Axis> axes = {QwtPlot::xBottom, QwtPlot::xTop, QwtPlot::yLeft, QwtPlot::yRight};
for ( QwtPlot::Axis axis : axes ) for ( QwtPlot::Axis axis : axes )
{ {
@ -139,14 +139,14 @@ void RiuQwtPlotTools::enableDateBasedBottomXAxis( QwtPlot*
{ {
QwtDateScaleDraw* scaleDraw = new QwtDateScaleDraw( Qt::UTC ); QwtDateScaleDraw* scaleDraw = new QwtDateScaleDraw( Qt::UTC );
std::set<QwtDate::IntervalType> intervals = { QwtDate::Year, std::set<QwtDate::IntervalType> intervals = {QwtDate::Year,
QwtDate::Month, QwtDate::Month,
QwtDate::Week, QwtDate::Week,
QwtDate::Day, QwtDate::Day,
QwtDate::Hour, QwtDate::Hour,
QwtDate::Minute, QwtDate::Minute,
QwtDate::Second, QwtDate::Second,
QwtDate::Millisecond }; QwtDate::Millisecond};
for ( QwtDate::IntervalType interval : intervals ) for ( QwtDate::IntervalType interval : intervals )
{ {

4
ApplicationCode/UserInterface/RiuQwtPlotWidget.cpp
View File

@ -647,7 +647,7 @@ RiuWidgetStyleSheet RiuQwtPlotWidget::createCanvasStyleSheet() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RiuQwtPlotWidget::setDefaults() void RiuQwtPlotWidget::setDefaults()
{ {
setEnabledAxes( { QwtPlot::xTop, QwtPlot::yLeft } ); setEnabledAxes( {QwtPlot::xTop, QwtPlot::yLeft} );
RiuQwtPlotTools::setCommonPlotBehaviour( this ); RiuQwtPlotTools::setCommonPlotBehaviour( this );
} }
@ -789,7 +789,7 @@ void RiuQwtPlotWidget::highlightCurve( const QwtPlotCurve* closestCurve )
symbol->setPen( blendedSymbolLineColor, symbol->pen().width(), symbol->pen().style() ); symbol->setPen( blendedSymbolLineColor, symbol->pen().width(), symbol->pen().style() );
} }
} }
CurveColors curveColors = { curveColor, symbolColor, symbolLineColor }; CurveColors curveColors = {curveColor, symbolColor, symbolLineColor};
m_originalCurveColors.insert( std::make_pair( plotCurve, curveColors ) ); m_originalCurveColors.insert( std::make_pair( plotCurve, curveColors ) );
m_originalCurveColors.insert( std::make_pair( plotCurve, curveColors ) ); m_originalCurveColors.insert( std::make_pair( plotCurve, curveColors ) );
m_originalZValues.insert( std::make_pair( plotCurve, zValue ) ); m_originalZValues.insert( std::make_pair( plotCurve, zValue ) );

2
ApplicationCode/UserInterface/RiuRmsNavigation.cpp
View File

@ -55,7 +55,7 @@ bool RiuRmsNavigation::handleInputEvent( QInputEvent* inputEvent )
if ( me->button() == Qt::MidButton && isRotationEnabled() ) if ( me->button() == Qt::MidButton && isRotationEnabled() )
{ {
this->pickAndSetPointOfInterest(me->x(), me->y()); this->pickAndSetPointOfInterest( me->x(), me->y() );
m_trackball->startNavigation( cvf::ManipulatorTrackball::ROTATE, translatedMousePosX, translatedMousePosY ); m_trackball->startNavigation( cvf::ManipulatorTrackball::ROTATE, translatedMousePosX, translatedMousePosY );
m_isNavigating = true; m_isNavigating = true;

98
ApplicationCode/UserInterface/RiuSummaryCurveDefSelection.cpp
View File

@ -92,55 +92,55 @@ private:
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RiuSummaryCurveDefSelection::RiuSummaryCurveDefSelection() RiuSummaryCurveDefSelection::RiuSummaryCurveDefSelection()
: m_identifierFieldsMap( { : m_identifierFieldsMap( {
{ RifEclipseSummaryAddress::SUMMARY_FIELD, {RifEclipseSummaryAddress::SUMMARY_FIELD,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_AQUIFER, {RifEclipseSummaryAddress::SUMMARY_AQUIFER,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_AQUIFER_NUMBER ) }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_AQUIFER_NUMBER )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_NETWORK, {RifEclipseSummaryAddress::SUMMARY_NETWORK,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_MISC, {RifEclipseSummaryAddress::SUMMARY_MISC,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_REGION, {RifEclipseSummaryAddress::SUMMARY_REGION,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_REGION_NUMBER ) }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_REGION_NUMBER )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_REGION_2_REGION, {RifEclipseSummaryAddress::SUMMARY_REGION_2_REGION,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_REGION_2_REGION ) }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_REGION_2_REGION )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_WELL_GROUP, {RifEclipseSummaryAddress::SUMMARY_WELL_GROUP,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_GROUP_NAME ) }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_GROUP_NAME )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_WELL, {RifEclipseSummaryAddress::SUMMARY_WELL,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_NAME ) }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_NAME )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION, {RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_NAME ) }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_NAME )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_CELL_IJK ) }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_CELL_IJK )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR, {RifEclipseSummaryAddress::SUMMARY_WELL_COMPLETION_LGR,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_LGR_NAME ) }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_LGR_NAME )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_NAME ) }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_NAME )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_CELL_IJK ) }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_CELL_IJK )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_WELL_LGR, {RifEclipseSummaryAddress::SUMMARY_WELL_LGR,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_LGR_NAME ) }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_LGR_NAME )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_NAME ) }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_NAME )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT, {RifEclipseSummaryAddress::SUMMARY_WELL_SEGMENT,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_NAME ) }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_WELL_NAME )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_SEGMENT_NUMBER ) }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_SEGMENT_NUMBER )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_BLOCK, {RifEclipseSummaryAddress::SUMMARY_BLOCK,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_CELL_IJK ) }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_CELL_IJK )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR, {RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_LGR_NAME ) }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_LGR_NAME )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_CELL_IJK ) }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_CELL_IJK )},
{ new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_CALCULATED, {RifEclipseSummaryAddress::SUMMARY_CALCULATED,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
{ RifEclipseSummaryAddress::SUMMARY_IMPORTED, {RifEclipseSummaryAddress::SUMMARY_IMPORTED,
{ { new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME ) } } }, {{new SummaryIdentifierAndField( RifEclipseSummaryAddress::INPUT_VECTOR_NAME )}}},
} ) } )
{ {
CAF_PDM_InitFieldNoDefault( &m_selectedSources, "SummaryCases", "Cases", "", "", "" ); CAF_PDM_InitFieldNoDefault( &m_selectedSources, "SummaryCases", "Cases", "", "", "" );

3920
ApplicationCode/UserInterface/RiuSummaryQuantityNameInfoProvider.cpp
View File

File diff suppressed because it is too large Load Diff

8
ApplicationCode/UserInterface/RiuViewer.cpp
View File

@ -182,7 +182,7 @@ RiuViewer::RiuViewer( const QGLFormat& format, QWidget* parent )
m_scaleLegend->setOrientation( caf::OverlayScaleLegend::HORIZONTAL ); m_scaleLegend->setOrientation( caf::OverlayScaleLegend::HORIZONTAL );
m_comparisonWindowMover = new RiuComparisonViewMover( this ); m_comparisonWindowMover = new RiuComparisonViewMover( this );
this->setComparisonViewToFollowAnimation(false); this->setComparisonViewToFollowAnimation( false );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -313,7 +313,7 @@ void RiuViewer::slotSetCurrentFrame( int frameIndex )
// Update views using this as comparison // Update views using this as comparison
Rim3dView* view = dynamic_cast<Rim3dView*>( m_rimView.p() ); Rim3dView* view = dynamic_cast<Rim3dView*>( m_rimView.p() );
if (view) if ( view )
{ {
std::set<Rim3dView*> containingViews = view->viewsUsingThisAsComparisonView(); std::set<Rim3dView*> containingViews = view->viewsUsingThisAsComparisonView();
@ -356,7 +356,7 @@ void RiuViewer::setOwnerReservoirView( RiuViewerToViewInterface* owner )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RiuViewer::paintOverlayItems( QPainter* painter ) void RiuViewer::paintOverlayItems( QPainter* painter )
{ {
// Update the legend layout on every redraw as the legends stores their own position, // Update the legend layout on every redraw as the legends stores their own position,
// and when they are shared between views the positions are overwritten. // and when they are shared between views the positions are overwritten.
updateLegendLayout(); updateLegendLayout();
@ -987,7 +987,7 @@ void RiuViewer::setAxisLabels( const cvf::String& xLabel, const cvf::String& yLa
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RiuViewerCommands* RiuViewer::viewerCommands() const RiuViewerCommands* RiuViewer::viewerCommands() const
{ {

10
ApplicationCode/UserInterface/RiuViewerCommands.cpp
View File

@ -1356,15 +1356,15 @@ void RiuViewerCommands::handleTextPicking( int winPosX, int winPosY, cvf::HitIte
{ {
for ( size_t pIdx = 0; pIdx < partCollection.size(); ++pIdx ) for ( size_t pIdx = 0; pIdx < partCollection.size(); ++pIdx )
{ {
DrawableText* textDrawable = dynamic_cast<DrawableText*>(partCollection[pIdx]->drawable()); DrawableText* textDrawable = dynamic_cast<DrawableText*>( partCollection[pIdx]->drawable() );
if ( textDrawable ) if ( textDrawable )
{ {
cvf::Vec3d ppoint; cvf::Vec3d ppoint;
if ( textDrawable->rayIntersect(*ray, *(m_viewer->mainCamera()), &ppoint) ) if ( textDrawable->rayIntersect( *ray, *( m_viewer->mainCamera() ), &ppoint ) )
{ {
cvf::ref<HitItem> hitItem = new HitItem(0, ppoint); cvf::ref<HitItem> hitItem = new HitItem( 0, ppoint );
hitItem->setPart(partCollection[pIdx].p()); hitItem->setPart( partCollection[pIdx].p() );
hitItems->add(hitItem.p()); hitItems->add( hitItem.p() );
} }
} }
} }