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

Fixes by clang-format

Browse Source
This commit is contained in:
magnesj 2020-11-09 12:44:29 +00:00 committed by Magne Sjaastad
parent b9706a0f77
commit 62eb603ed2
204 changed files with 67512 additions and 67423 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationCode/Application/RiaApplication.cpp
View File

@ -341,7 +341,7 @@ bool RiaApplication::openFile( const QString& fileName )
}
else if ( int( fileType ) & int( RiaDefines::ImportFileType::ANY_ECLIPSE_FILE ) )
{
loadingSucceded = RicImportGeneralDataFeature::openEclipseFilesFromFileNames( QStringList{fileName}, true );
loadingSucceded = RicImportGeneralDataFeature::openEclipseFilesFromFileNames( QStringList{ fileName }, true );
lastUsedDialogTag = RiaDefines::defaultDirectoryLabel( fileType );
}
@ -1865,7 +1865,7 @@ bool RiaApplication::generateCode( const QString& fileName, QString* errMsg )
std::vector<std::shared_ptr<const caf::PdmObject>> commandObjects;
QStringList excludedClassNames{"TestCommand1", "TC2"}; // See RifCommandCore-Text.cpp
QStringList excludedClassNames{ "TestCommand1", "TC2" }; // See RifCommandCore-Text.cpp
auto allObjects = caf::PdmMarkdownBuilder::createAllObjects( caf::PdmDefaultObjectFactory::instance() );
for ( auto classObject : allObjects )

20
ApplicationCode/Application/RiaDefines.cpp
View File

@ -414,15 +414,15 @@ QString RiaDefines::formationAllanResultName()
//--------------------------------------------------------------------------------------------------
std::set<QString> RiaDefines::nncResultNames()
{
return {combinedTransmissibilityResultName(),
formationAllanResultName(),
formationBinaryAllanResultName(),
combinedWaterFluxResultName(),
combinedGasFluxResultName(),
combinedOilFluxResultName(),
combinedRiAreaNormTranResultName(),
combinedRiMultResultName(),
combinedRiTranResultName()};
return { combinedTransmissibilityResultName(),
formationAllanResultName(),
formationBinaryAllanResultName(),
combinedWaterFluxResultName(),
combinedGasFluxResultName(),
combinedOilFluxResultName(),
combinedRiAreaNormTranResultName(),
combinedRiMultResultName(),
combinedRiTranResultName() };
}
//--------------------------------------------------------------------------------------------------
@ -542,7 +542,7 @@ QString RiaDefines::wbsSFGResult()
//--------------------------------------------------------------------------------------------------
std::vector<QString> RiaDefines::wbsAngleResultNames()
{
return {wbsAzimuthResult(), wbsInclinationResult()};
return { wbsAzimuthResult(), wbsInclinationResult() };
}
//--------------------------------------------------------------------------------------------------

6
ApplicationCode/Application/RiaPreferences.cpp
View File

@ -471,7 +471,7 @@ void RiaPreferences::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering&
colorGroup->add( &defaultGridLineColors, false );
colorGroup->add( &defaultFaultGridLineColors );
colorGroup->add( &defaultWellLabelColor, false );
colorGroup->add( &m_guiTheme, {true, 2} );
colorGroup->add( &m_guiTheme, { true, 2 } );
caf::PdmUiGroup* fontGroup = uiOrdering.addNewGroup( "Default Font Sizes" );
fontGroup->add( &defaultSceneFontSize );
@ -485,9 +485,9 @@ void RiaPreferences::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering&
viewsGroup->add( &m_defaultScaleFactorZ );
viewsGroup->add( &m_showLegendBackground );
viewsGroup->add( &m_enableFaultsByDefault, {false, 1} );
viewsGroup->add( &m_enableFaultsByDefault, { false, 1 } );
viewsGroup->add( &m_showInfoBox );
viewsGroup->add( &m_showGridBox, {false, 1} );
viewsGroup->add( &m_showGridBox, { false, 1 } );
caf::PdmUiGroup* otherGroup = uiOrdering.addNewGroup( "Other" );
otherGroup->add( &ssihubAddress );

4
ApplicationCode/Application/Tools/RiaCellDividingTools.cpp
View File

@ -71,7 +71,7 @@ std::vector<cvf::Vec3d>
std::make_pair( 2, 6 ), // Z
};
std::array<size_t, 3> nxyz = {nx, ny, nz};
std::array<size_t, 3> nxyz = { nx, ny, nz };
std::array<std::vector<cvf::Vec3d>, 12> edgePoints;
for ( int i = 0; i < 12; i++ )
@ -167,7 +167,7 @@ double RiaCellDividingTools::computeFlowDistance( const std::array<cvf::Vec3d, 8
//--------------------------------------------------------------------------------------------------
std::vector<cvf::Vec3d> splitLine( cvf::Vec3d ptStart, cvf::Vec3d ptEnd, size_t partCount )
{
std::vector<cvf::Vec3d> pts = {ptStart};
std::vector<cvf::Vec3d> pts = { ptStart };
for ( size_t i = 1; i < partCount; i++ )
{

151
ApplicationCode/Application/Tools/RiaColorTables.cpp
View File

@ -28,13 +28,13 @@
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::normalPaletteColors()
{
static std::vector<cvf::Color3ub> colors{cvf::Color3ub( 0, 0, 255 ),
cvf::Color3ub( 0, 127, 255 ),
cvf::Color3ub( 0, 255, 255 ),
cvf::Color3ub( 0, 255, 0 ),
cvf::Color3ub( 255, 255, 0 ),
cvf::Color3ub( 255, 127, 0 ),
cvf::Color3ub( 255, 0, 0 )};
static std::vector<cvf::Color3ub> colors{ cvf::Color3ub( 0, 0, 255 ),
cvf::Color3ub( 0, 127, 255 ),
cvf::Color3ub( 0, 255, 255 ),
cvf::Color3ub( 0, 255, 0 ),
cvf::Color3ub( 255, 255, 0 ),
cvf::Color3ub( 255, 127, 0 ),
cvf::Color3ub( 255, 0, 0 ) };
static caf::ColorTable colorTable = caf::ColorTable( colors );
@ -46,13 +46,13 @@ const caf::ColorTable& RiaColorTables::normalPaletteColors()
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::normalPaletteOppositeOrderingColors()
{
static std::vector<cvf::Color3ub> colors{cvf::Color3ub( 255, 0, 0 ),
cvf::Color3ub( 255, 127, 0 ),
cvf::Color3ub( 255, 255, 0 ),
cvf::Color3ub( 0, 255, 0 ),
cvf::Color3ub( 0, 255, 255 ),
cvf::Color3ub( 0, 127, 255 ),
cvf::Color3ub( 0, 0, 255 )};
static std::vector<cvf::Color3ub> colors{ cvf::Color3ub( 255, 0, 0 ),
cvf::Color3ub( 255, 127, 0 ),
cvf::Color3ub( 255, 255, 0 ),
cvf::Color3ub( 0, 255, 0 ),
cvf::Color3ub( 0, 255, 255 ),
cvf::Color3ub( 0, 127, 255 ),
cvf::Color3ub( 0, 0, 255 ) };
static caf::ColorTable colorTable = caf::ColorTable( colors );
@ -64,7 +64,7 @@ const caf::ColorTable& RiaColorTables::normalPaletteOppositeOrderingColors()
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::blackWhitePaletteColors()
{
static std::vector<cvf::Color3ub> colors{cvf::Color3ub::BLACK, cvf::Color3ub::WHITE};
static std::vector<cvf::Color3ub> colors{ cvf::Color3ub::BLACK, cvf::Color3ub::WHITE };
static caf::ColorTable colorTable = caf::ColorTable( colors );
@ -76,7 +76,7 @@ const caf::ColorTable& RiaColorTables::blackWhitePaletteColors()
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::whiteBlackPaletteColors()
{
static std::vector<cvf::Color3ub> colors{cvf::Color3ub::WHITE, cvf::Color3ub::BLACK};
static std::vector<cvf::Color3ub> colors{ cvf::Color3ub::WHITE, cvf::Color3ub::BLACK };
static caf::ColorTable colorTable = caf::ColorTable( colors );
@ -88,7 +88,7 @@ const caf::ColorTable& RiaColorTables::whiteBlackPaletteColors()
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::pinkWhitePaletteColors()
{
static std::vector<cvf::Color3ub> colors{cvf::Color3ub::DEEP_PINK, cvf::Color3ub::WHITE};
static std::vector<cvf::Color3ub> colors{ cvf::Color3ub::DEEP_PINK, cvf::Color3ub::WHITE };
static caf::ColorTable colorTable = caf::ColorTable( colors );
@ -100,7 +100,7 @@ const caf::ColorTable& RiaColorTables::pinkWhitePaletteColors()
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::whitePinkPaletteColors()
{
static std::vector<cvf::Color3ub> colors{cvf::Color3ub::WHITE, cvf::Color3ub::DEEP_PINK};
static std::vector<cvf::Color3ub> colors{ cvf::Color3ub::WHITE, cvf::Color3ub::DEEP_PINK };
static caf::ColorTable colorTable = caf::ColorTable( colors );
@ -112,7 +112,7 @@ const caf::ColorTable& RiaColorTables::whitePinkPaletteColors()
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::blueWhiteRedPaletteColors()
{
static std::vector<cvf::Color3ub> colors{cvf::Color3ub::BLUE, cvf::Color3ub::WHITE, cvf::Color3ub::RED};
static std::vector<cvf::Color3ub> colors{ cvf::Color3ub::BLUE, cvf::Color3ub::WHITE, cvf::Color3ub::RED };
static caf::ColorTable colorTable = caf::ColorTable( colors );
@ -124,7 +124,7 @@ const caf::ColorTable& RiaColorTables::blueWhiteRedPaletteColors()
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::redWhiteBluePaletteColors()
{
static std::vector<cvf::Color3ub> colors{cvf::Color3ub::RED, cvf::Color3ub::WHITE, cvf::Color3ub::BLUE};
static std::vector<cvf::Color3ub> colors{ cvf::Color3ub::RED, cvf::Color3ub::WHITE, cvf::Color3ub::BLUE };
static caf::ColorTable colorTable = caf::ColorTable( colors );
@ -201,15 +201,15 @@ const caf::ColorTable& RiaColorTables::tensorsMagentaBrownGrayPaletteColors()
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::angularPaletteColors()
{
static std::vector<cvf::Color3ub> colors{cvf::Color3ub( 255, 0, 255 ),
cvf::Color3ub( 0, 0, 255 ),
cvf::Color3ub( 0, 127, 255 ),
cvf::Color3ub( 0, 255, 255 ),
cvf::Color3ub( 0, 255, 0 ),
cvf::Color3ub( 255, 255, 0 ),
cvf::Color3ub( 255, 127, 0 ),
cvf::Color3ub( 255, 0, 0 ),
cvf::Color3ub( 255, 0, 255 )};
static std::vector<cvf::Color3ub> colors{ cvf::Color3ub( 255, 0, 255 ),
cvf::Color3ub( 0, 0, 255 ),
cvf::Color3ub( 0, 127, 255 ),
cvf::Color3ub( 0, 255, 255 ),
cvf::Color3ub( 0, 255, 0 ),
cvf::Color3ub( 255, 255, 0 ),
cvf::Color3ub( 255, 127, 0 ),
cvf::Color3ub( 255, 0, 0 ),
cvf::Color3ub( 255, 0, 255 ) };
static caf::ColorTable colorTable = caf::ColorTable( colors );
@ -221,14 +221,14 @@ const caf::ColorTable& RiaColorTables::angularPaletteColors()
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::rainbowPaletteColors()
{
static std::vector<cvf::Color3ub> colors{cvf::Color3ub::BLACK,
cvf::Color3ub::MAGENTA,
cvf::Color3ub::BLUE,
cvf::Color3ub::CYAN,
cvf::Color3ub::GREEN,
cvf::Color3ub::RED,
cvf::Color3ub::YELLOW,
cvf::Color3ub::WHITE};
static std::vector<cvf::Color3ub> colors{ cvf::Color3ub::BLACK,
cvf::Color3ub::MAGENTA,
cvf::Color3ub::BLUE,
cvf::Color3ub::CYAN,
cvf::Color3ub::GREEN,
cvf::Color3ub::RED,
cvf::Color3ub::YELLOW,
cvf::Color3ub::WHITE };
static caf::ColorTable colorTable = caf::ColorTable( colors );
return colorTable;
@ -404,18 +404,18 @@ const caf::ColorTable& RiaColorTables::summaryCurveNoneRedGreenBlueBrownPaletteC
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::wellLogPlotPaletteColors()
{
static std::vector<cvf::Color3ub> colors{caf::ColorTable::fromQColor( QColor( "peru" ) ),
caf::ColorTable::fromQColor( QColor( "blueviolet" ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::darkYellow ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::darkCyan ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::darkMagenta ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::darkGray ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::yellow ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::magenta ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::cyan ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::gray ) ),
caf::ColorTable::fromQColor( QColor( "yellowgreen" ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::black ) )};
static std::vector<cvf::Color3ub> colors{ caf::ColorTable::fromQColor( QColor( "peru" ) ),
caf::ColorTable::fromQColor( QColor( "blueviolet" ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::darkYellow ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::darkCyan ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::darkMagenta ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::darkGray ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::yellow ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::magenta ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::cyan ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::gray ) ),
caf::ColorTable::fromQColor( QColor( "yellowgreen" ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::black ) ) };
static caf::ColorTable colorTable = caf::ColorTable( colors );
@ -427,13 +427,13 @@ const caf::ColorTable& RiaColorTables::wellLogPlotPaletteColors()
//--------------------------------------------------------------------------------------------------
const caf::ColorTable& RiaColorTables::selectionPaletteColors()
{
static std::vector<cvf::Color3ub> colors{caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::magenta ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::cyan ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::blue ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::red ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::green ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::yellow ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::gray ) )};
static std::vector<cvf::Color3ub> colors{ caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::magenta ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::cyan ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::blue ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::red ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::green ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::yellow ) ),
caf::ColorTable::fromQColor( Qt::GlobalColor( Qt::gray ) ) };
static caf::ColorTable colorTable = caf::ColorTable( colors );
@ -542,17 +542,17 @@ cvf::Color3f RiaColorTables::undefinedCellColor()
//--------------------------------------------------------------------------------------------------
RiaColorTables::WellPathComponentColors RiaColorTables::wellPathComponentColors()
{
return {{RiaDefines::WellPathComponentType::WELL_PATH, cvf::Color3::CEETRON},
{RiaDefines::WellPathComponentType::PERFORATION_INTERVAL, cvf::Color3::DARK_MAGENTA},
{RiaDefines::WellPathComponentType::FISHBONES, cvf::Color3::DARK_GREEN},
{RiaDefines::WellPathComponentType::FRACTURE, cvf::Color3::CRIMSON},
{RiaDefines::WellPathComponentType::ICD, cvf::Color3::DARK_ORANGE},
{RiaDefines::WellPathComponentType::AICD, cvf::Color3::INDIGO},
{RiaDefines::WellPathComponentType::ICV, cvf::Color3::ORCHID},
{RiaDefines::WellPathComponentType::CASING, cvf::Color3::SEA_GREEN},
{RiaDefines::WellPathComponentType::LINER, cvf::Color3::OLIVE},
{RiaDefines::WellPathComponentType::PACKER, cvf::Color3::GRAY},
{RiaDefines::WellPathComponentType::UNDEFINED_COMPONENT, cvf::Color3::MAGENTA}};
return { { RiaDefines::WellPathComponentType::WELL_PATH, cvf::Color3::CEETRON },
{ RiaDefines::WellPathComponentType::PERFORATION_INTERVAL, cvf::Color3::DARK_MAGENTA },
{ RiaDefines::WellPathComponentType::FISHBONES, cvf::Color3::DARK_GREEN },
{ RiaDefines::WellPathComponentType::FRACTURE, cvf::Color3::CRIMSON },
{ RiaDefines::WellPathComponentType::ICD, cvf::Color3::DARK_ORANGE },
{ RiaDefines::WellPathComponentType::AICD, cvf::Color3::INDIGO },
{ RiaDefines::WellPathComponentType::ICV, cvf::Color3::ORCHID },
{ RiaDefines::WellPathComponentType::CASING, cvf::Color3::SEA_GREEN },
{ RiaDefines::WellPathComponentType::LINER, cvf::Color3::OLIVE },
{ RiaDefines::WellPathComponentType::PACKER, cvf::Color3::GRAY },
{ RiaDefines::WellPathComponentType::UNDEFINED_COMPONENT, cvf::Color3::MAGENTA } };
}
//--------------------------------------------------------------------------------------------------
@ -618,15 +618,16 @@ caf::ColorTable RiaColorTables::createBrightnessBasedColorTable( cvf::Color3ub b
//--------------------------------------------------------------------------------------------------
std::map<RiaDefines::PhaseType, caf::ColorTable> RiaColorTables::phaseColors()
{
static std::vector<cvf::Color3ub> waterColors{cvf::Color3ub( cvf::Color3::DARK_BLUE ),
cvf::Color3ub( cvf::Color3::SKY_BLUE )};
static std::vector<cvf::Color3ub> gasColors{cvf::Color3ub( cvf::Color3::DARK_RED ), cvf::Color3ub( cvf::Color3::PINK )};
static std::vector<cvf::Color3ub> oilColors{cvf::Color3ub( cvf::Color3::DARK_GREEN ),
cvf::Color3ub( cvf::Color3::YELLOW_GREEN )};
static std::vector<cvf::Color3ub> waterColors{ cvf::Color3ub( cvf::Color3::DARK_BLUE ),
cvf::Color3ub( cvf::Color3::SKY_BLUE ) };
static std::vector<cvf::Color3ub> gasColors{ cvf::Color3ub( cvf::Color3::DARK_RED ),
cvf::Color3ub( cvf::Color3::PINK ) };
static std::vector<cvf::Color3ub> oilColors{ cvf::Color3ub( cvf::Color3::DARK_GREEN ),
cvf::Color3ub( cvf::Color3::YELLOW_GREEN ) };
return {{RiaDefines::PhaseType::WATER_PHASE, caf::ColorTable( waterColors )},
{RiaDefines::PhaseType::GAS_PHASE, caf::ColorTable( gasColors )},
{RiaDefines::PhaseType::OIL_PHASE, caf::ColorTable( oilColors )}};
return { { RiaDefines::PhaseType::WATER_PHASE, caf::ColorTable( waterColors ) },
{ RiaDefines::PhaseType::GAS_PHASE, caf::ColorTable( gasColors ) },
{ RiaDefines::PhaseType::OIL_PHASE, caf::ColorTable( oilColors ) } };
}
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/Application/Tools/RiaDateStringParser.cpp
View File

@ -24,7 +24,7 @@
#include <algorithm>
const std::string MONTH_NAMES[] =
{"january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"};
{ "january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december" };
//--------------------------------------------------------------------------------------------------
///

8
ApplicationCode/Application/Tools/RiaInterpolationTools.cpp
View File

@ -132,8 +132,8 @@ int RiaInterpolationTools::extrapolateRange( int start,
const std::vector<double>& x,
std::vector<double>& y )
{
std::vector<double> xs = {x[firstPoint], x[lastPoint]};
std::vector<double> ys = {y[firstPoint], y[lastPoint]};
std::vector<double> xs = { x[firstPoint], x[lastPoint] };
std::vector<double> ys = { y[firstPoint], y[lastPoint] };
for ( int index = start; index < end; index++ )
{
y[index] = extrapolate( xs, ys, x[index] );
@ -154,8 +154,8 @@ int RiaInterpolationTools::interpolateRange( int start,
{
assert( start <= end );
std::vector<double> xs = {x[firstPoint], x[lastPoint]};
std::vector<double> ys = {y[firstPoint], y[lastPoint]};
std::vector<double> xs = { x[firstPoint], x[lastPoint] };
std::vector<double> ys = { y[firstPoint], y[lastPoint] };
for ( int index = start; index < end; index++ )
{
y[index] = RiaInterpolationTools::linear( xs, ys, x[index] );

2
ApplicationCode/Application/Tools/RiaQDateTimeTools.cpp
View File

@ -521,7 +521,7 @@ QList<caf::PdmOptionItemInfo> RiaQDateTimeTools::createOptionItems( const std::v
{
const auto& dt = dateTimes[i];
QString text = RiaQDateTimeTools::toStringUsingApplicationLocale( dt, formatString );
options.push_back( {text, static_cast<int>( i )} );
options.push_back( { text, static_cast<int>( i ) } );
}
return options;

36
ApplicationCode/Application/Tools/WellPathTools/RiaLineArcWellPathCalculator.cpp
View File

@ -43,30 +43,30 @@ RiaLineArcWellPathCalculator::RiaLineArcWellPathCalculator( const cvf::Vec3d&
{
m_lineArcEndpoints.push_back( activeWellPathTargets[0].targetPointXYZ + referencePointXyz );
m_targetStatuses.resize( activeWellPathTargets.size(),
{!activeWellPathTargets[0].isTangentConstrained,
0.0,
0.0,
false,
true,
std::numeric_limits<double>::infinity(),
false,
true,
std::numeric_limits<double>::infinity()} );
{ !activeWellPathTargets[0].isTangentConstrained,
0.0,
0.0,
false,
true,
std::numeric_limits<double>::infinity(),
false,
true,
std::numeric_limits<double>::infinity() } );
}
return;
}
m_targetStatuses.resize( activeWellPathTargets.size(),
{false,
0.0,
0.0,
false,
false,
std::numeric_limits<double>::infinity(),
false,
false,
std::numeric_limits<double>::infinity()} );
{ false,
0.0,
0.0,
false,
false,
std::numeric_limits<double>::infinity(),
false,
false,
std::numeric_limits<double>::infinity() } );
std::vector<WellTarget> adjustedWellPathTargets = activeWellPathTargets;

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;
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 );
segment.inc = cvf::Math::toDegrees( startAziIncRad.inc() );
@ -80,7 +80,7 @@ void RiaWellPlanCalculator::addSegment( cvf::Vec3d t1, cvf::Vec3d p1, cvf::Vec3d
//--------------------------------------------------------------------------------------------------
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;
double length = p1p2.length();
@ -110,7 +110,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 )
{
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 );

4
ApplicationCode/CommandFileInterface/RicfCreateLgrForCompletions.cpp
View File

@ -118,7 +118,9 @@ caf::PdmScriptResponse RicfCreateLgrForCompletions::execute()
m_timeStep,
lgrCellCounts,
m_splitType(),
{RigCompletionData::PERFORATION, RigCompletionData::FRACTURE, RigCompletionData::FISHBONES},
{ RigCompletionData::PERFORATION,
RigCompletionData::FRACTURE,
RigCompletionData::FISHBONES },
&wellsIntersectingOtherLgrs );
feature->updateViews( eclipseCase );

4
ApplicationCode/CommandFileInterface/RicfExportLgrForCompletions.cpp
View File

@ -111,7 +111,9 @@ caf::PdmScriptResponse RicfExportLgrForCompletions::execute()
m_timeStep,
lgrCellCounts,
m_splitType(),
{RigCompletionData::PERFORATION, RigCompletionData::FRACTURE, RigCompletionData::FISHBONES},
{ RigCompletionData::PERFORATION,
RigCompletionData::FRACTURE,
RigCompletionData::FISHBONES },
&wellsIntersectingOtherLgrs );
caf::PdmScriptResponse response;

2
ApplicationCode/CommandFileInterface/RicfExportMsw.cpp
View File

@ -97,7 +97,7 @@ caf::PdmScriptResponse RicfExportMsw::execute()
return caf::PdmScriptResponse( caf::PdmScriptResponse::COMMAND_ERROR, error );
}
RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions( exportSettings, {wellPath} );
RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions( exportSettings, { wellPath } );
return caf::PdmScriptResponse();
}

2
ApplicationCode/CommandFileInterface/RicfLoadCase.cpp
View File

@ -64,7 +64,7 @@ caf::PdmScriptResponse RicfLoadCase::execute()
}
RiaImportEclipseCaseTools::FileCaseIdMap fileCaseIdMap;
bool ok = RiaImportEclipseCaseTools::openEclipseCasesFromFile( QStringList( {absolutePath} ), &fileCaseIdMap, true );
bool ok = RiaImportEclipseCaseTools::openEclipseCasesFromFile( QStringList( { absolutePath } ), &fileCaseIdMap, true );
if ( !ok )
{
QString error = QString( "loadCase: Unable to load case from %1" ).arg( absolutePath );

2
ApplicationCode/Commands/AnnotationCommands/RicCreateTextAnnotationIn3dViewFeature.cpp
View File

@ -88,7 +88,7 @@ void RicCreateTextAnnotationIn3dViewFeature::onActionTriggered( bool isChecked )
cvf::Vec3d horizontalUp = viewCamera->up() - ( cvf::Vec3d::Z_AXIS * ( viewCamera->up() * cvf::Vec3d::Z_AXIS ) );
bool isOk = horizontalRight.normalize();
if ( !isOk ) horizontalRight = {1.0, 0.0, 0.0};
if ( !isOk ) horizontalRight = { 1.0, 0.0, 0.0 };
double height = fabs( labelPos.z() - domainCoord.z() );
newAnnotation->setLabelPoint( labelPos + 2.0 * height * ( horizontalRight + horizontalUp ) );

80
ApplicationCode/Commands/CompletionCommands/RicNewFractureModelPlotFeature.cpp
View File

@ -95,33 +95,33 @@ RimFractureModelPlot*
auto task = progInfo.task( "Creating parameters track", 15 );
std::map<QString, PlotDefVector> plots;
plots["Porosity"] = {std::make_tuple( "PORO",
RiaDefines::ResultCatType::STATIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE,
false,
RiaDefines::CurveProperty::POROSITY )};
plots["Porosity"] = { std::make_tuple( "PORO",
RiaDefines::ResultCatType::STATIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE,
false,
RiaDefines::CurveProperty::POROSITY ) };
plots["Pressure"] = {std::make_tuple( "PRESSURE",
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION,
true,
RiaDefines::CurveProperty::INITIAL_PRESSURE ),
std::make_tuple( "PRESSURE",
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::OTHER_CURVE_PROPERTY,
false,
RiaDefines::CurveProperty::PRESSURE )};
plots["Pressure"] = { std::make_tuple( "PRESSURE",
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::LINEAR_INTERPOLATION,
true,
RiaDefines::CurveProperty::INITIAL_PRESSURE ),
std::make_tuple( "PRESSURE",
RiaDefines::ResultCatType::DYNAMIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::OTHER_CURVE_PROPERTY,
false,
RiaDefines::CurveProperty::PRESSURE ) };
plots["Permeability"] = {std::make_tuple( "PERMX",
RiaDefines::ResultCatType::STATIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE,
false,
RiaDefines::CurveProperty::PERMEABILITY_X ),
std::make_tuple( "PERMZ",
RiaDefines::ResultCatType::STATIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE,
false,
RiaDefines::CurveProperty::PERMEABILITY_Z )};
plots["Permeability"] = { std::make_tuple( "PERMX",
RiaDefines::ResultCatType::STATIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE,
false,
RiaDefines::CurveProperty::PERMEABILITY_X ),
std::make_tuple( "PERMZ",
RiaDefines::ResultCatType::STATIC_NATIVE,
RimFractureModelCurve::MissingValueStrategy::DEFAULT_VALUE,
false,
RiaDefines::CurveProperty::PERMEABILITY_Z ) };
std::set<QString> logarithmicPlots;
logarithmicPlots.insert( "Permeability" );
@ -140,30 +140,30 @@ RimFractureModelPlot*
eclipseCase,
timeStep,
"Stress",
{RiaDefines::CurveProperty::STRESS, RiaDefines::CurveProperty::INITIAL_STRESS} );
{ RiaDefines::CurveProperty::STRESS, RiaDefines::CurveProperty::INITIAL_STRESS } );
createStressTrack( plot,
fractureModel,
eclipseCase,
timeStep,
"Stress Gradient",
{RiaDefines::CurveProperty::STRESS_GRADIENT} );
{ RiaDefines::CurveProperty::STRESS_GRADIENT } );
}
{
auto task = progInfo.task( "Creating facies properties track", 15 );
std::vector<RiaDefines::CurveProperty> results = {RiaDefines::CurveProperty::YOUNGS_MODULUS,
RiaDefines::CurveProperty::POISSONS_RATIO,
RiaDefines::CurveProperty::BIOT_COEFFICIENT,
RiaDefines::CurveProperty::K0,
RiaDefines::CurveProperty::K_IC,
RiaDefines::CurveProperty::PROPPANT_EMBEDMENT,
RiaDefines::CurveProperty::FLUID_LOSS_COEFFICIENT,
RiaDefines::CurveProperty::SPURT_LOSS,
RiaDefines::CurveProperty::RELATIVE_PERMEABILITY_FACTOR,
RiaDefines::CurveProperty::PORO_ELASTIC_CONSTANT,
RiaDefines::CurveProperty::THERMAL_EXPANSION_COEFFICIENT,
RiaDefines::CurveProperty::IMMOBILE_FLUID_SATURATION};
std::vector<RiaDefines::CurveProperty> results = { RiaDefines::CurveProperty::YOUNGS_MODULUS,
RiaDefines::CurveProperty::POISSONS_RATIO,
RiaDefines::CurveProperty::BIOT_COEFFICIENT,
RiaDefines::CurveProperty::K0,
RiaDefines::CurveProperty::K_IC,
RiaDefines::CurveProperty::PROPPANT_EMBEDMENT,
RiaDefines::CurveProperty::FLUID_LOSS_COEFFICIENT,
RiaDefines::CurveProperty::SPURT_LOSS,
RiaDefines::CurveProperty::RELATIVE_PERMEABILITY_FACTOR,
RiaDefines::CurveProperty::PORO_ELASTIC_CONSTANT,
RiaDefines::CurveProperty::THERMAL_EXPANSION_COEFFICIENT,
RiaDefines::CurveProperty::IMMOBILE_FLUID_SATURATION };
for ( auto result : results )
{
@ -173,7 +173,7 @@ RimFractureModelPlot*
{
auto task = progInfo.task( "Creating temperature track", 2 );
createStressTrack( plot, fractureModel, eclipseCase, timeStep, "Temperature", {RiaDefines::CurveProperty::TEMPERATURE} );
createStressTrack( plot, fractureModel, eclipseCase, timeStep, "Temperature", { RiaDefines::CurveProperty::TEMPERATURE } );
}
{

2
ApplicationCode/Commands/CompletionExportCommands/RicExportCompletionsWellSegmentsFeature.cpp
View File

@ -113,7 +113,7 @@ void RicExportCompletionsWellSegmentsFeature::onActionTriggered( bool isChecked
completionExportSettings.includePerforations = perforationCollection != nullptr &&
!perforationCollection->activePerforations().empty();
RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions( completionExportSettings, {wellPath} );
RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions( completionExportSettings, { wellPath } );
}
}

46
ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp
View File

@ -179,7 +179,7 @@ std::vector<RigCompletionData>
{
// Load the data required by fracture summary header
std::vector<QString> resultNames{"TRANX", "TRANY", "TRANZ"};
std::vector<QString> resultNames{ "TRANX", "TRANY", "TRANZ" };
RicExportFractureCompletionsImpl::loadResultsByName( cellResultsData, resultNames );
}
@ -560,12 +560,12 @@ void RicExportFractureCompletionsImpl::calculateInternalFractureTransmissibiliti
fractureCellNeighbourX.cellSizeZ(),
cDarcyInCorrectUnit );
transCondenser.addNeighborTransmissibility( {false,
RigTransmissibilityCondenser::CellAddress::STIMPLAN,
fractureCellIndex},
{false,
RigTransmissibilityCondenser::CellAddress::STIMPLAN,
fractureCellNeighbourXIndex},
transCondenser.addNeighborTransmissibility( { false,
RigTransmissibilityCondenser::CellAddress::STIMPLAN,
fractureCellIndex },
{ false,
RigTransmissibilityCondenser::CellAddress::STIMPLAN,
fractureCellNeighbourXIndex },
horizontalTransToXneigbour );
}
@ -583,12 +583,12 @@ void RicExportFractureCompletionsImpl::calculateInternalFractureTransmissibiliti
fractureCellNeighbourZ.cellSizeX(),
cDarcyInCorrectUnit );
transCondenser.addNeighborTransmissibility( {false,
RigTransmissibilityCondenser::CellAddress::STIMPLAN,
fractureCellIndex},
{false,
RigTransmissibilityCondenser::CellAddress::STIMPLAN,
fractureCellNeighbourZIndex},
transCondenser.addNeighborTransmissibility( { false,
RigTransmissibilityCondenser::CellAddress::STIMPLAN,
fractureCellIndex },
{ false,
RigTransmissibilityCondenser::CellAddress::STIMPLAN,
fractureCellNeighbourZIndex },
verticalTransToZneigbour );
}
}
@ -624,8 +624,8 @@ void RicExportFractureCompletionsImpl::calculateFractureToWellTransmissibilities
fracTemplate->skinFactor(),
cDarcyInCorrectUnit );
transCondenser.addNeighborTransmissibility( {true, RigTransmissibilityCondenser::CellAddress::WELL, 1},
{false, RigTransmissibilityCondenser::CellAddress::STIMPLAN, wellCellIndex},
transCondenser.addNeighborTransmissibility( { true, RigTransmissibilityCondenser::CellAddress::WELL, 1 },
{ false, RigTransmissibilityCondenser::CellAddress::STIMPLAN, wellCellIndex },
radialTrans );
}
else if ( fracTemplate->orientationType() == RimFractureTemplate::ALONG_WELL_PATH )
@ -660,10 +660,10 @@ void RicExportFractureCompletionsImpl::calculateFractureToWellTransmissibilities
fracture->wellRadius() );
}
transCondenser.addNeighborTransmissibility( {true, RigTransmissibilityCondenser::CellAddress::WELL, 1},
{false,
RigTransmissibilityCondenser::CellAddress::STIMPLAN,
fracWellCellIdx},
transCondenser.addNeighborTransmissibility( { true, RigTransmissibilityCondenser::CellAddress::WELL, 1 },
{ false,
RigTransmissibilityCondenser::CellAddress::STIMPLAN,
fracWellCellIdx },
linearTrans );
}
}
@ -684,7 +684,7 @@ std::map<size_t, double>
{
double trans =
transCondenser.condensedTransmissibility( externalCell,
{true, RigTransmissibilityCondenser::CellAddress::WELL, 1} );
{ true, RigTransmissibilityCondenser::CellAddress::WELL, 1 } );
if ( trans > transCondenser.transmissibilityThreshold() )
{
@ -833,9 +833,9 @@ void RicExportFractureCompletionsImpl::outputIntermediateResultsText( QTextStrea
bool RicExportFractureCompletionsImpl::loadResultsByName( RigCaseCellResultsData* cellResultsData,
const std::vector<QString>& resultNames )
{
const std::vector<RiaDefines::ResultCatType> resultCategorySearchOrder = {RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::ResultCatType::INPUT_PROPERTY,
RiaDefines::ResultCatType::GENERATED};
const std::vector<RiaDefines::ResultCatType> resultCategorySearchOrder = { RiaDefines::ResultCatType::STATIC_NATIVE,
RiaDefines::ResultCatType::INPUT_PROPERTY,
RiaDefines::ResultCatType::GENERATED };
bool foundDataForAllResults = true;

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

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

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

@ -293,16 +293,15 @@ void RicWellPathExportMswCompletionsImpl::generateWelsegsTable( RifTextDataTable
}
{
std::vector<RifTextDataTableColumn> header = {RifTextDataTableColumn( "First Seg" ),
RifTextDataTableColumn( "Last Seg" ),
RifTextDataTableColumn( "Branch Num" ),
RifTextDataTableColumn( "Outlet Seg" ),
RifTextDataTableColumn( "Length" ),
RifTextDataTableColumn( "Depth Change" ),
RifTextDataTableColumn( "Diam" ),
RifTextDataTableColumn( "Rough",
RifTextDataTableDoubleFormatting( RIF_FLOAT,
7 ) )};
std::vector<RifTextDataTableColumn> header =
{ RifTextDataTableColumn( "First Seg" ),
RifTextDataTableColumn( "Last Seg" ),
RifTextDataTableColumn( "Branch Num" ),
RifTextDataTableColumn( "Outlet Seg" ),
RifTextDataTableColumn( "Length" ),
RifTextDataTableColumn( "Depth Change" ),
RifTextDataTableColumn( "Diam" ),
RifTextDataTableColumn( "Rough", RifTextDataTableDoubleFormatting( RIF_FLOAT, 7 ) ) };
formatter.header( header );
}
@ -328,15 +327,15 @@ void RicWellPathExportMswCompletionsImpl::generateWelsegsTable( RifTextDataTable
{
generateWelsegsSegments( formatter,
exportInfo,
{RigCompletionData::FISHBONES_ICD, RigCompletionData::FISHBONES},
{ RigCompletionData::FISHBONES_ICD, RigCompletionData::FISHBONES },
maxSegmentLength,
&segmentNumber );
generateWelsegsSegments( formatter, exportInfo, {RigCompletionData::FRACTURE}, maxSegmentLength, &segmentNumber );
generateWelsegsSegments( formatter, exportInfo, { RigCompletionData::FRACTURE }, maxSegmentLength, &segmentNumber );
generateWelsegsSegments( formatter,
exportInfo,
{RigCompletionData::PERFORATION_ICD,
RigCompletionData::PERFORATION_ICV,
RigCompletionData::PERFORATION_AICD},
{ RigCompletionData::PERFORATION_ICD,
RigCompletionData::PERFORATION_ICV,
RigCompletionData::PERFORATION_AICD },
maxSegmentLength,
&segmentNumber );
}
@ -429,8 +428,8 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegTables( RifTextDataTabl
*/
{
std::set<RigCompletionData::CompletionType> fishbonesTypes = {RigCompletionData::FISHBONES_ICD,
RigCompletionData::FISHBONES};
std::set<RigCompletionData::CompletionType> fishbonesTypes = { RigCompletionData::FISHBONES_ICD,
RigCompletionData::FISHBONES };
generateCompsegTable( formatter, exportInfo, false, fishbonesTypes );
if ( exportInfo.hasSubGridIntersections() )
{
@ -439,7 +438,7 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegTables( RifTextDataTabl
}
{
std::set<RigCompletionData::CompletionType> fractureTypes = {RigCompletionData::FRACTURE};
std::set<RigCompletionData::CompletionType> fractureTypes = { RigCompletionData::FRACTURE };
generateCompsegTable( formatter, exportInfo, false, fractureTypes );
if ( exportInfo.hasSubGridIntersections() )
{
@ -448,10 +447,10 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegTables( RifTextDataTabl
}
{
std::set<RigCompletionData::CompletionType> perforationTypes = {RigCompletionData::PERFORATION,
RigCompletionData::PERFORATION_ICD,
RigCompletionData::PERFORATION_ICV,
RigCompletionData::PERFORATION_AICD};
std::set<RigCompletionData::CompletionType> perforationTypes = { RigCompletionData::PERFORATION,
RigCompletionData::PERFORATION_ICD,
RigCompletionData::PERFORATION_ICV,
RigCompletionData::PERFORATION_AICD };
generateCompsegTable( formatter, exportInfo, false, perforationTypes );
if ( exportInfo.hasSubGridIntersections() )
{
@ -562,7 +561,7 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegHeader( RifTextDataTabl
}
{
std::vector<RifTextDataTableColumn> header = {RifTextDataTableColumn( "Name" )};
std::vector<RifTextDataTableColumn> header = { RifTextDataTableColumn( "Name" ) };
formatter.header( header );
formatter.add( exportInfo.wellPath()->completions()->wellNameForExport() );
formatter.rowCompleted();
@ -575,15 +574,15 @@ void RicWellPathExportMswCompletionsImpl::generateCompsegHeader( RifTextDataTabl
allHeaders.push_back( RifTextDataTableColumn( "Grid" ) );
}
std::vector<RifTextDataTableColumn> commonHeaders = {RifTextDataTableColumn( "I" ),
RifTextDataTableColumn( "J" ),
RifTextDataTableColumn( "K" ),
RifTextDataTableColumn( "Branch no" ),
RifTextDataTableColumn( "Start Length" ),
RifTextDataTableColumn( "End Length" ),
RifTextDataTableColumn( "Dir Pen" ),
RifTextDataTableColumn( "End Range" ),
RifTextDataTableColumn( "Connection Depth" )};
std::vector<RifTextDataTableColumn> commonHeaders = { RifTextDataTableColumn( "I" ),
RifTextDataTableColumn( "J" ),
RifTextDataTableColumn( "K" ),
RifTextDataTableColumn( "Branch no" ),
RifTextDataTableColumn( "Start Length" ),
RifTextDataTableColumn( "End Length" ),
RifTextDataTableColumn( "Dir Pen" ),
RifTextDataTableColumn( "End Range" ),
RifTextDataTableColumn( "Connection Depth" ) };
allHeaders.insert( allHeaders.end(), commonHeaders.begin(), commonHeaders.end() );
formatter.header( allHeaders );
}
@ -670,27 +669,27 @@ void RicWellPathExportMswCompletionsImpl::generateWsegAicdTable( RifTextDataTabl
if ( !foundValve )
{
std::vector<QString> columnDescriptions =
{"Well Name",
"Segment Number",
"Segment Number",
"Strength of AICD",
"Flow Scaling Factor for AICD",
"Density of Calibration Fluid",
"Viscosity of Calibration Fluid",
"Critical water in liquid fraction for emulsions viscosity model",
"Emulsion viscosity transition region",
"Max ratio of emulsion viscosity to continuous phase viscosity",
"Flow scaling factor method",
"Maximum flowrate for AICD device",
"Volume flow rate exponent, x",
"Viscosity function exponent, y",
"Device OPEN/SHUT",
"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 gas flowing fraction in the density mixture 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 gas flowing fraction in the density viscosity calculation"};
{ "Well Name",
"Segment Number",
"Segment Number",
"Strength of AICD",
"Flow Scaling Factor for AICD",
"Density of Calibration Fluid",
"Viscosity of Calibration Fluid",
"Critical water in liquid fraction for emulsions viscosity model",
"Emulsion viscosity transition region",
"Max ratio of emulsion viscosity to continuous phase viscosity",
"Flow scaling factor method",
"Maximum flowrate for AICD device",
"Volume flow rate exponent, x",
"Viscosity function exponent, y",
"Device OPEN/SHUT",
"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 gas flowing fraction in the density mixture 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 gas flowing fraction in the density viscosity calculation" };
tighterFormatter.keyword( "WSEGAICD" );
tighterFormatter.comment( "Column Overview:" );
@ -1031,7 +1030,7 @@ RicMswExportInfo
RicExportFractureCompletionsImpl::generateCompdatValues( caseToApply,
wellPath->completions()->wellNameForExport(),
wellPath->wellPathGeometry(),
{fracture},
{ fracture },
nullptr,
nullptr );

12
ApplicationCode/Commands/CompletionExportCommands/RicWellPathFractureTextReportFeatureImpl.cpp
View File

@ -725,11 +725,11 @@ QString RicWellPathFractureTextReportFeatureImpl::createFracturePressureDepletio
RifTextDataTableFormatter formatter( stream );
configureFormatter( &formatter );
std::vector<RifTextDataTableColumn> header = {RifTextDataTableColumn( "Well" ),
RifTextDataTableColumn( "Fracture" ),
RifTextDataTableColumn( "Actual WBHP" ),
RifTextDataTableColumn( "Min Pressure Drop" ),
RifTextDataTableColumn( "Max Pressure Drop" )};
std::vector<RifTextDataTableColumn> header = { RifTextDataTableColumn( "Well" ),
RifTextDataTableColumn( "Fracture" ),
RifTextDataTableColumn( "Actual WBHP" ),
RifTextDataTableColumn( "Min Pressure Drop" ),
RifTextDataTableColumn( "Max Pressure Drop" ) };
bool createdTable = false;
@ -776,7 +776,7 @@ QString RicWellPathFractureTextReportFeatureImpl::createConnectionsPerWellText(
RifTextDataTableFormatter formatter( stream );
configureFormatter( &formatter );
std::vector<RifTextDataTableColumn> header = {RifTextDataTableColumn( "Well" ), floatNumberColumn( "ConnCount" )};
std::vector<RifTextDataTableColumn> header = { RifTextDataTableColumn( "Well" ), floatNumberColumn( "ConnCount" ) };
formatter.header( header );
formatter.addHorizontalLine( '-' );

22
ApplicationCode/Commands/ExportCommands/RicExportCarfin.cpp
View File

@ -81,17 +81,17 @@ void RicExportCarfin::onActionTriggered( bool isChecked )
QTextStream stream( &exportFile );
RifTextDataTableFormatter formatter( stream );
std::vector<RifTextDataTableColumn> header = {RifTextDataTableColumn( "I1" ),
RifTextDataTableColumn( "I2" ),
RifTextDataTableColumn( "J1" ),
RifTextDataTableColumn( "J2" ),
RifTextDataTableColumn( "K1" ),
RifTextDataTableColumn( "K2" ),
RifTextDataTableColumn( "NX" ),
RifTextDataTableColumn( "NY" ),
RifTextDataTableColumn( "NZ" ),
RifTextDataTableColumn( "NWMAX" ),
RifTextDataTableColumn( "Parent LGR" )};
std::vector<RifTextDataTableColumn> header = { RifTextDataTableColumn( "I1" ),
RifTextDataTableColumn( "I2" ),
RifTextDataTableColumn( "J1" ),
RifTextDataTableColumn( "J2" ),
RifTextDataTableColumn( "K1" ),
RifTextDataTableColumn( "K2" ),
RifTextDataTableColumn( "NX" ),
RifTextDataTableColumn( "NY" ),
RifTextDataTableColumn( "NZ" ),
RifTextDataTableColumn( "NWMAX" ),
RifTextDataTableColumn( "Parent LGR" ) };
formatter.keyword( "CARFIN" );
formatter.header( header );

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

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

30
ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelUi.cpp
View File

@ -301,16 +301,16 @@ void RicExportEclipseSectorModelUi::defineUiOrdering( QString uiConfigName, caf:
exportInLocalCoordinates.uiCapability()->setUiReadOnly( !exportGrid() );
caf::PdmUiGroup* gridBoxGroup = uiOrdering.addNewGroup( "Grid Box Selection" );
gridBoxGroup->add( &exportGridBox, {true, 4, 1} );
gridBoxGroup->add( &exportGridBox, { true, 4, 1 } );
gridBoxGroup->add( &minI, {true, 2, 1} );
gridBoxGroup->add( &minI, { true, 2, 1 } );
gridBoxGroup->add( &minJ, false );
gridBoxGroup->add( &minK, false );
gridBoxGroup->add( &maxI, {true, 2, 1} );
gridBoxGroup->add( &maxI, { true, 2, 1 } );
gridBoxGroup->add( &maxJ, false );
gridBoxGroup->add( &maxK, false );
gridBoxGroup->add( &makeInvisibleCellsInactive, {true, 2, 1} );
gridBoxGroup->add( &makeInvisibleCellsInactive, { true, 2, 1 } );
minI.uiCapability()->setUiReadOnly( exportGridBox() != MANUAL_SELECTION );
minJ.uiCapability()->setUiReadOnly( exportGridBox() != MANUAL_SELECTION );
@ -320,9 +320,9 @@ void RicExportEclipseSectorModelUi::defineUiOrdering( QString uiConfigName, caf:
maxK.uiCapability()->setUiReadOnly( exportGridBox() != MANUAL_SELECTION );
caf::PdmUiGroup* gridRefinement = uiOrdering.addNewGroup( "Grid Refinement" );
gridRefinement->add( &refinementCountI, {true, 2, 1} );
gridRefinement->add( &refinementCountJ, {false} );
gridRefinement->add( &refinementCountK, {false} );
gridRefinement->add( &refinementCountI, { true, 2, 1 } );
gridRefinement->add( &refinementCountJ, { false } );
gridRefinement->add( &refinementCountK, { false } );
refinementCountI.uiCapability()->setUiReadOnly( !exportGrid() );
refinementCountJ.uiCapability()->setUiReadOnly( !exportGrid() );
refinementCountK.uiCapability()->setUiReadOnly( !exportGrid() );
@ -478,9 +478,9 @@ QList<caf::PdmOptionItemInfo>
}
else if ( fieldNeedingOptions == &exportFaults )
{
std::set<ResultExportOptions> validFaultOptions = {EXPORT_NO_RESULTS,
EXPORT_TO_GRID_FILE,
EXPORT_TO_SINGLE_SEPARATE_FILE};
std::set<ResultExportOptions> validFaultOptions = { EXPORT_NO_RESULTS,
EXPORT_TO_GRID_FILE,
EXPORT_TO_SINGLE_SEPARATE_FILE };
if ( !exportGrid() ) validFaultOptions.erase( EXPORT_TO_GRID_FILE );
for ( ResultExportOptions option : validFaultOptions )
{
@ -489,10 +489,10 @@ QList<caf::PdmOptionItemInfo>
}
else if ( fieldNeedingOptions == &exportParameters )
{
std::set<ResultExportOptions> validFaultOptions = {EXPORT_NO_RESULTS,
EXPORT_TO_GRID_FILE,
EXPORT_TO_SINGLE_SEPARATE_FILE,
EXPORT_TO_SEPARATE_FILE_PER_RESULT};
std::set<ResultExportOptions> validFaultOptions = { EXPORT_NO_RESULTS,
EXPORT_TO_GRID_FILE,
EXPORT_TO_SINGLE_SEPARATE_FILE,
EXPORT_TO_SEPARATE_FILE_PER_RESULT };
if ( !exportGrid() ) validFaultOptions.erase( EXPORT_TO_GRID_FILE );
for ( ResultExportOptions option : validFaultOptions )
{
@ -507,7 +507,7 @@ QList<caf::PdmOptionItemInfo>
//--------------------------------------------------------------------------------------------------
std::set<QString> RicExportEclipseSectorModelUi::mainKeywords()
{
return {RiaDefines::eqlnumResultName(), "FIPNUM", "NTG", "PERMX", "PERMY", "PERMZ", "PORO", "PVTNUM", "SATNUM", "SWATINIT"};
return { RiaDefines::eqlnumResultName(), "FIPNUM", "NTG", "PERMX", "PERMY", "PERMZ", "PORO", "PVTNUM", "SATNUM", "SWATINIT" };
}
//--------------------------------------------------------------------------------------------------

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

@ -132,8 +132,8 @@ class IjkBoundingBox
public:
IjkBoundingBox()
: m_min( {MAX_SIZE_T, MAX_SIZE_T, MAX_SIZE_T} )
, m_max( {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 } )
{
}
@ -168,7 +168,7 @@ public:
{
if ( !isValid() )
{
m_min = m_max = {i, j, k};
m_min = m_max = { i, j, k };
}
else
{
@ -360,16 +360,16 @@ void RicExportLgrFeature::writeLgrs( QTextStream& stream, const std::vector<LgrI
RifTextDataTableFormatter formatter( stream );
formatter.comment( QString( "LGR: " ) + lgrInfo.name );
formatter.keyword( "CARFIN" );
formatter.header( {RifTextDataTableColumn( "Name" ),
RifTextDataTableColumn( "I1" ),
RifTextDataTableColumn( "I2" ),
RifTextDataTableColumn( "J1" ),
RifTextDataTableColumn( "J2" ),
RifTextDataTableColumn( "K1" ),
RifTextDataTableColumn( "K2" ),
RifTextDataTableColumn( "NX" ),
RifTextDataTableColumn( "NY" ),
RifTextDataTableColumn( "NZ" )} );
formatter.header( { RifTextDataTableColumn( "Name" ),
RifTextDataTableColumn( "I1" ),
RifTextDataTableColumn( "I2" ),
RifTextDataTableColumn( "J1" ),
RifTextDataTableColumn( "J2" ),
RifTextDataTableColumn( "K1" ),
RifTextDataTableColumn( "K2" ),
RifTextDataTableColumn( "NX" ),
RifTextDataTableColumn( "NY" ),
RifTextDataTableColumn( "NZ" ) } );
formatter.add( lgrInfo.name );
formatter.addOneBasedCellIndex( lgrInfo.mainGridStartCell.i() );
@ -535,7 +535,7 @@ std::vector<LgrInfo>
for ( const auto& intersectionCell : intersectingCells )
{
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;
}
@ -922,9 +922,9 @@ const RigGridBase* RicExportLgrFeature::hostGrid( const RigMainGrid* mainGrid, s
//--------------------------------------------------------------------------------------------------
LgrNameFactory::LgrNameFactory()
{
m_counters = {{RigCompletionData::FRACTURE, {"FRAC", 1}},
{RigCompletionData::FISHBONES, {"FB", 1}},
{RigCompletionData::PERFORATION, {"PERF", 1}}};
m_counters = { { RigCompletionData::FRACTURE, { "FRAC", 1 } },
{ RigCompletionData::FISHBONES, { "FB", 1 } },
{ RigCompletionData::PERFORATION, { "PERF", 1 } } };
}
//--------------------------------------------------------------------------------------------------

8
ApplicationCode/Commands/ExportCommands/RicExportLgrUi.cpp
View File

@ -230,12 +230,12 @@ void RicExportLgrUi::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering&
uiOrdering.add( &m_includeFractures, layout );
uiOrdering.add( &m_includeFishbones, layout );
uiOrdering.add( &m_includePerforations, layout );
uiOrdering.add( &m_splitType, {true, 6, 1} );
uiOrdering.add( &m_splitType, { true, 6, 1 } );
caf::PdmUiGroup* gridRefinement = uiOrdering.addNewGroup( "Grid Refinement" );
gridRefinement->add( &m_cellCountI, {true, 2, 1} );
gridRefinement->add( &m_cellCountJ, {false} );
gridRefinement->add( &m_cellCountK, {false} );
gridRefinement->add( &m_cellCountI, { true, 2, 1 } );
gridRefinement->add( &m_cellCountJ, { false } );
gridRefinement->add( &m_cellCountK, { false } );
// uiOrdering.add(&m_wellPathsInfo);
uiOrdering.skipRemainingFields( true );

8
ApplicationCode/Commands/ExportCommands/RicExportSelectedWellPathsFeature.cpp
View File

@ -117,10 +117,10 @@ void RicExportSelectedWellPathsFeature::writeWellPathGeometryToStream( QTextStre
stream << "WELLNAME: '" << caf::Utils::makeValidFileBasename( exportName ) << "'" << endl;
auto numberFormat = RifTextDataTableDoubleFormatting( RIF_FLOAT, 2 );
formatter.header( {{"X", numberFormat, RIGHT},
{"Y", numberFormat, RIGHT},
{"TVDMSL", numberFormat, RIGHT},
{useMdRkb ? "MDRKB" : "MDMSL", numberFormat, RIGHT}} );
formatter.header( { { "X", numberFormat, RIGHT },
{ "Y", numberFormat, RIGHT },
{ "TVDMSL", numberFormat, RIGHT },
{ useMdRkb ? "MDRKB" : "MDMSL", numberFormat, RIGHT } } );
for ( size_t i = 0; i < xValues.size(); i++ )
{

2
ApplicationCode/Commands/FractureCommands/RicCreateMultipleFracturesUi.cpp
View File

@ -307,7 +307,7 @@ void RiuCreateMultipleFractionsUi::defineEditorAttribute( const caf::PdmFieldHan
if ( attr )
{
attr->minimumHeight = 130;
attr->columnWidths = {90, 90, 400, 70};
attr->columnWidths = { 90, 90, 400, 70 };
}
}
}

2
ApplicationCode/Commands/FractureCommands/RicNewFractureModelFeature.cpp
View File

@ -74,7 +74,7 @@ RimFractureModel* RicNewFractureModelFeature::addFractureModel( RimWellPath*
RimModeledWellPath* thicknessDirectionWellPath = new RimModeledWellPath;
fractureModel->setThicknessDirectionWellPath( thicknessDirectionWellPath );
std::vector<RimWellPath*> wellPaths = {thicknessDirectionWellPath};
std::vector<RimWellPath*> wellPaths = { thicknessDirectionWellPath };
wellPathCollection->addWellPaths( wellPaths );
if ( project )

58
ApplicationCode/Commands/HoloLensCommands/VdeCachingHashedIdFactory.cpp
View File

@ -159,35 +159,35 @@ int VdeCachingHashedIdFactory::getOrCreateIdForArrOfType( ArrayRole arrayRole,
//==================================================================================================
static const unsigned int crc_table[256] =
{0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832,
0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a,
0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab,
0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4,
0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074,
0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525,
0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76,
0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6,
0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7,
0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7,
0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330,
0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d};
{ 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832,
0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a,
0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab,
0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4,
0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074,
0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525,
0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76,
0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6,
0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7,
0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7,
0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330,
0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d };
//--------------------------------------------------------------------------------------------------
///

2
ApplicationCode/Commands/RicFaciesPropertiesImportTools.cpp
View File

@ -143,7 +143,7 @@ bool RicFaciesPropertiesImportTools::matchByName( const QString& name, RimColorL
int RicFaciesPropertiesImportTools::computeEditDistance( const QString& a, const QString& b )
{
// Remove common words from the domain which does not help in the matching
std::vector<QString> stopWords = {"rocks", "rock", "stones", "stone"};
std::vector<QString> stopWords = { "rocks", "rock", "stones", "stone" };
QString aSimplified = a.toLower();
QString bSimplified = b.toLower();
for ( auto r : stopWords )

2
ApplicationCode/Commands/RicImportEnsembleFeature.cpp
View File

@ -95,7 +95,7 @@ void RicImportEnsembleFeature::onActionTriggered( bool isChecked )
if ( ensemble )
{
RicNewSummaryEnsembleCurveSetFeature::createPlotForCurveSetsAndUpdate( {ensemble} );
RicNewSummaryEnsembleCurveSetFeature::createPlotForCurveSetsAndUpdate( { ensemble } );
}
std::vector<RimCase*> allCases;

2
ApplicationCode/Commands/RicRecursiveFileSearchDialog.cpp
View File

@ -267,7 +267,7 @@ QStringList RicRecursiveFileSearchDialog::fileExtensions() const
QString extFromFilter = extensionFromFileNameFilter();
if ( !extFromFilter.isEmpty() )
{
return QStringList( {extFromFilter} );
return QStringList( { extFromFilter } );
}
QStringList exts = m_fileExtensions;

8
ApplicationCode/Commands/RicSummaryCaseRestartDialog.cpp
View File

@ -266,7 +266,7 @@ RicSummaryCaseRestartDialogResult RicSummaryCaseRestartDialog::openDialog( const
defaultSummaryImportOption,
defaultGridImportOption,
{},
QStringList( {initialGridFile} ),
QStringList( { initialGridFile } ),
useFirstSummaryCaseAsTemplate ||
( lastResult && lastResult->applyToAll ) );
}
@ -281,8 +281,8 @@ RicSummaryCaseRestartDialogResult RicSummaryCaseRestartDialog::openDialog( const
return RicSummaryCaseRestartDialogResult( RicSummaryCaseRestartDialogResult::SUMMARY_OK,
NOT_IMPORT,
NOT_IMPORT,
QStringList( {initialSummaryFile} ),
QStringList( {initialGridFile} ),
QStringList( { initialSummaryFile } ),
QStringList( { initialGridFile } ),
useFirstSummaryCaseAsTemplate || lastResult->applyToAll );
}
@ -356,7 +356,7 @@ RicSummaryCaseRestartDialogResult RicSummaryCaseRestartDialog::openDialog( const
// Remove common root path
std::vector<std::vector<std::pair<RifRestartFileInfo, QString>>> fileInfosNoRoot =
makeShortPath( {currentFileInfos, originSummaryFileInfos, originGridFileInfos} );
makeShortPath( { currentFileInfos, originSummaryFileInfos, originGridFileInfos } );
// Populate file list backing lists
dialog.m_fileLists.push_back( fileInfosNoRoot[CURRENT_FILES_LIST_INDEX] );

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

@ -286,7 +286,7 @@ void RicSummaryPlotFeatureImpl::createSummaryPlotsFromArgumentLine( const QStrin
QStringList gridFileNames;
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 )
{

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

@ -264,9 +264,9 @@ void RicNewWellBoreStabilityPlotFeature::createParametersTrack( RimWellBoreStabi
std::set<RigWbsParameter> parameters = RigWbsParameter::allParameters();
caf::ColorTable colors = RiaColorTables::contrastCategoryPaletteColors();
std::vector<RiuQwtPlotCurve::LineStyleEnum> lineStyles = {RiuQwtPlotCurve::STYLE_SOLID,
RiuQwtPlotCurve::STYLE_DASH,
RiuQwtPlotCurve::STYLE_DASH_DOT};
std::vector<RiuQwtPlotCurve::LineStyleEnum> lineStyles = { RiuQwtPlotCurve::STYLE_SOLID,
RiuQwtPlotCurve::STYLE_DASH,
RiuQwtPlotCurve::STYLE_DASH_DOT };
size_t i = 0;
for ( const RigWbsParameter& param : parameters )
@ -313,12 +313,12 @@ void RicNewWellBoreStabilityPlotFeature::createStabilityCurvesTrack( RimWellBore
std::vector<QString> resultNames = RiaDefines::wbsDerivedResultNames();
std::vector<cvf::Color3f> colors = {cvf::Color3f::BLUE,
cvf::Color3f::BROWN,
cvf::Color3f::RED,
cvf::Color3f::PURPLE,
cvf::Color3f::DARK_GREEN,
cvf::Color3f::OLIVE};
std::vector<cvf::Color3f> colors = { cvf::Color3f::BLUE,
cvf::Color3f::BROWN,
cvf::Color3f::RED,
cvf::Color3f::PURPLE,
cvf::Color3f::DARK_GREEN,
cvf::Color3f::OLIVE };
std::vector<RiuQwtPlotCurve::LineStyleEnum> lineStyles( resultNames.size(), RiuQwtPlotCurve::STYLE_SOLID );
lineStyles.back() = RiuQwtPlotCurve::STYLE_DASH;
@ -379,9 +379,9 @@ void RicNewWellBoreStabilityPlotFeature::createAnglesTrack( RimWellBoreStability
const double angleIncrement = 90.0;
std::vector<QString> resultNames = RiaDefines::wbsAngleResultNames();
std::vector<cvf::Color3f> colors = {cvf::Color3f::GREEN, cvf::Color3f::DARK_ORANGE};
std::vector<cvf::Color3f> colors = { cvf::Color3f::GREEN, cvf::Color3f::DARK_ORANGE };
std::vector<RiuQwtPlotCurve::LineStyleEnum> lineStyles = {RiuQwtPlotCurve::STYLE_DASH, RiuQwtPlotCurve::STYLE_SOLID};
std::vector<RiuQwtPlotCurve::LineStyleEnum> lineStyles = { RiuQwtPlotCurve::STYLE_DASH, RiuQwtPlotCurve::STYLE_SOLID };
for ( size_t i = 0; i < resultNames.size(); ++i )
{

38
ApplicationCode/Commands/WellPathCommands/PointTangentManipulator/RicPointTangentManipulatorPartMgr.cpp
View File

@ -265,22 +265,22 @@ cvf::ref<cvf::DrawableGeo> RicPointTangentManipulatorPartMgr::createHorizontalPl
float cos_5pi_12 = cvf::Math::cos( 5.5 * cvf::PI_F / 12 );
float sin_5pi_12 = cvf::Math::sin( 5.5 * cvf::PI_F / 12 );
vertexArray->set( 0, {1.25, 0, 0} );
vertexArray->set( 1, {cos_pi_12, sin_pi_12, 0} );
vertexArray->set( 2, {cos_3pi_12, sin_3pi_12, 0} );
vertexArray->set( 3, {cos_5pi_12, sin_5pi_12, 0} );
vertexArray->set( 4, {0, 1.25, 0} );
vertexArray->set( 5, {-cos_5pi_12, sin_5pi_12, 0} );
vertexArray->set( 6, {-cos_3pi_12, sin_3pi_12, 0} );
vertexArray->set( 7, {-cos_pi_12, sin_pi_12, 0} );
vertexArray->set( 8, {-1.25, 0, 0} );
vertexArray->set( 9, {-cos_pi_12, -sin_pi_12, 0} );
vertexArray->set( 10, {-cos_3pi_12, -sin_3pi_12, 0} );
vertexArray->set( 11, {-cos_5pi_12, -sin_5pi_12, 0} );
vertexArray->set( 12, {0, -1.25, 0} );
vertexArray->set( 13, {cos_5pi_12, -sin_5pi_12, 0} );
vertexArray->set( 14, {cos_3pi_12, -sin_3pi_12, 0} );
vertexArray->set( 15, {cos_pi_12, -sin_pi_12, 0} );
vertexArray->set( 0, { 1.25, 0, 0 } );
vertexArray->set( 1, { cos_pi_12, sin_pi_12, 0 } );
vertexArray->set( 2, { cos_3pi_12, sin_3pi_12, 0 } );
vertexArray->set( 3, { cos_5pi_12, sin_5pi_12, 0 } );
vertexArray->set( 4, { 0, 1.25, 0 } );
vertexArray->set( 5, { -cos_5pi_12, sin_5pi_12, 0 } );
vertexArray->set( 6, { -cos_3pi_12, sin_3pi_12, 0 } );
vertexArray->set( 7, { -cos_pi_12, sin_pi_12, 0 } );
vertexArray->set( 8, { -1.25, 0, 0 } );
vertexArray->set( 9, { -cos_pi_12, -sin_pi_12, 0 } );
vertexArray->set( 10, { -cos_3pi_12, -sin_3pi_12, 0 } );
vertexArray->set( 11, { -cos_5pi_12, -sin_5pi_12, 0 } );
vertexArray->set( 12, { 0, -1.25, 0 } );
vertexArray->set( 13, { cos_5pi_12, -sin_5pi_12, 0 } );
vertexArray->set( 14, { cos_3pi_12, -sin_3pi_12, 0 } );
vertexArray->set( 15, { cos_pi_12, -sin_pi_12, 0 } );
Vec3f origin( m_origin );
for ( cvf::Vec3f& vx : *vertexArray )
@ -339,7 +339,7 @@ cvf::ref<cvf::DrawableGeo> RicPointTangentManipulatorPartMgr::createVerticalAxis
float s = 0.5 * m_handleSize;
Vec3f origin( m_origin );
geomBuilder->transformVertexRange( 0, geomBuilder->vertexCount() - 1, cvf::Mat4f::fromScaling( {s, s, s} ) );
geomBuilder->transformVertexRange( 0, geomBuilder->vertexCount() - 1, cvf::Mat4f::fromScaling( { s, s, s } ) );
geomBuilder->transformVertexRange( 0, geomBuilder->vertexCount() - 1, cvf::Mat4f::fromTranslation( origin ) );
unsigned vxArraySizeFirstCylinder = geomBuilder->vertexCount();
@ -348,10 +348,10 @@ cvf::ref<cvf::DrawableGeo> RicPointTangentManipulatorPartMgr::createVerticalAxis
geomBuilder->transformVertexRange( vxArraySizeFirstCylinder,
geomBuilder->vertexCount() - 1,
cvf::Mat4f::fromTranslation( {0.0f, 0.0f, -1.0f} ) );
cvf::Mat4f::fromTranslation( { 0.0f, 0.0f, -1.0f } ) );
geomBuilder->transformVertexRange( vxArraySizeFirstCylinder,
geomBuilder->vertexCount() - 1,
cvf::Mat4f::fromScaling( {s, s, s} ) );
cvf::Mat4f::fromScaling( { s, s, s } ) );
geomBuilder->transformVertexRange( vxArraySizeFirstCylinder,
geomBuilder->vertexCount() - 1,
cvf::Mat4f::fromTranslation( origin ) );

4
ApplicationCode/Commands/WellPathCommands/RicNewPolylineTargetFeature.cpp
View File

@ -102,7 +102,7 @@ void RicNewPolylineTargetFeature::onActionTriggered( bool isChecked )
}
auto* newTarget = new RimPolylineTarget;
newTarget->setAsPointTargetXYD( {newPos[0], newPos[1], -newPos[2]} );
newTarget->setAsPointTargetXYD( { newPos[0], newPos[1], -newPos[2] } );
polylineDef->insertTarget( firstTarget, newTarget );
polylineDef->updateConnectedEditors();
@ -151,7 +151,7 @@ void RicNewPolylineTargetFeature::onActionTriggered( bool isChecked )
}
auto* newTarget = new RimPolylineTarget;
newTarget->setAsPointTargetXYD( {newPos[0], newPos[1], -newPos[2]} );
newTarget->setAsPointTargetXYD( { newPos[0], newPos[1], -newPos[2] } );
polylineDef->insertTarget( nullptr, newTarget );
}

6
ApplicationCode/Commands/WellPathCommands/RicNewWellPathListTargetFeature.cpp
View File

@ -120,11 +120,11 @@ void RicNewWellPathListTargetFeature::onActionTriggered( bool isChecked )
RimWellPathTarget* newTarget = new RimWellPathTarget;
if ( isSeaLevelTarget )
{
newTarget->setAsPointXYZAndTangentTarget( {newPos[0], newPos[1], newPos[2]}, 0, 0 );
newTarget->setAsPointXYZAndTangentTarget( { newPos[0], newPos[1], newPos[2] }, 0, 0 );
}
else
{
newTarget->setAsPointTargetXYD( {newPos[0], newPos[1], -newPos[2]} );
newTarget->setAsPointTargetXYD( { newPos[0], newPos[1], -newPos[2] } );
}
wellGeomDef->insertTarget( firstTarget, newTarget );
@ -163,7 +163,7 @@ void RicNewWellPathListTargetFeature::onActionTriggered( bool isChecked )
}
RimWellPathTarget* newTarget = new RimWellPathTarget;
newTarget->setAsPointTargetXYD( {newPos[0], newPos[1], -newPos[2]} );
newTarget->setAsPointTargetXYD( { newPos[0], newPos[1], -newPos[2] } );
wellGeomDef->insertTarget( nullptr, newTarget );
}

2
ApplicationCode/FileInterface/RifCsvUserDataParser.cpp
View File

@ -63,7 +63,7 @@ enum class CsvLineBasedColumnType
ERROR_VALUE,
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" };
//--------------------------------------------------------------------------------------------------
///

2
ApplicationCode/FileInterface/RifEclipseInputFileTools.cpp
View File

@ -309,7 +309,7 @@ bool RifEclipseInputFileTools::exportGrid( const QString& fileName,
cvf::Vec2f origin( mapAxes[2] - minPoint2f.x(), mapAxes[3] - minPoint2f.y() );
cvf::Vec2f xPoint = cvf::Vec2f( mapAxes[4], mapAxes[5] ) - minPoint2f;
cvf::Vec2f yPoint = cvf::Vec2f( mapAxes[0], mapAxes[1] ) - minPoint2f;
mapAxes = {yPoint.x(), yPoint.y(), origin.x(), origin.y(), xPoint.x(), xPoint.y()};
mapAxes = { yPoint.x(), yPoint.y(), origin.x(), origin.y(), xPoint.x(), xPoint.y() };
mapAxisTrans.setTranslation( mapAxisTrans.translation() - minPoint3d );
}

18
ApplicationCode/FileInterface/RifEclipseUserDataKeywordTools.cpp
View File

@ -36,27 +36,27 @@ std::vector<size_t> RifEclipseUserDataKeywordTools::requiredItemsPerLineForKeywo
switch ( firstLetter )
{
case 'B':
return {3}; // Block triplet
return { 3 }; // Block triplet
case 'C':
return {1, 3}; // Well Name and completion triplet
return { 1, 3 }; // Well Name and completion triplet
case 'G':
return {1}; // Group
return { 1 }; // Group
case 'R':
return {1}; // Region number
return { 1 }; // Region number
case 'S':
return {1, 1}; // Well name and segment number
return { 1, 1 }; // Well name and segment number
case 'W':
return {1}; // Well Name
return { 1 }; // Well Name
}
std::string firstTwoLetters = identifier.substr( 0, 2 );
if ( firstTwoLetters == "LB" )
return {1, 3}; // LGR name and block triplet
return { 1, 3 }; // LGR name and block triplet
else if ( firstTwoLetters == "LC" )
return {1, 1, 3}; // LGR name, well name and block triplet
return { 1, 1, 3 }; // LGR name, well name and block triplet
else if ( firstTwoLetters == "LW" )
return {1, 1}; // LGR name and well name
return { 1, 1 }; // LGR name and well name
return {};
}

2
ApplicationCode/FileInterface/RifEclipseUserDataParserTools.cpp
View File

@ -99,7 +99,7 @@ bool RifEclipseUserDataParserTools::isAComment( const std::string& word )
std::vector<std::string> RifEclipseUserDataParserTools::splitLineAndRemoveComments( const std::string& line )
{
std::istringstream iss( line );
std::vector<std::string> words{std::istream_iterator<std::string>{iss}, std::istream_iterator<std::string>{}};
std::vector<std::string> words{ std::istream_iterator<std::string>{ iss }, std::istream_iterator<std::string>{} };
for ( auto wordsIterator = words.begin(); wordsIterator != words.end(); ++wordsIterator )
{

8
ApplicationCode/FileInterface/RifEnsembleStatisticsReader.cpp
View File

@ -32,10 +32,10 @@ RifEnsembleStatisticsReader::RifEnsembleStatisticsReader( RimEnsembleStatisticsC
m_ensembleStatCase = ensStatCase;
m_allResultAddresses = std::set<RifEclipseSummaryAddress>(
{RifEclipseSummaryAddress::ensembleStatisticsAddress( ENSEMBLE_STAT_P10_QUANTITY_NAME, "" ),
RifEclipseSummaryAddress::ensembleStatisticsAddress( ENSEMBLE_STAT_P50_QUANTITY_NAME, "" ),
RifEclipseSummaryAddress::ensembleStatisticsAddress( ENSEMBLE_STAT_P90_QUANTITY_NAME, "" ),
RifEclipseSummaryAddress::ensembleStatisticsAddress( ENSEMBLE_STAT_MEAN_QUANTITY_NAME, "" )} );
{ RifEclipseSummaryAddress::ensembleStatisticsAddress( ENSEMBLE_STAT_P10_QUANTITY_NAME, "" ),
RifEclipseSummaryAddress::ensembleStatisticsAddress( ENSEMBLE_STAT_P50_QUANTITY_NAME, "" ),
RifEclipseSummaryAddress::ensembleStatisticsAddress( ENSEMBLE_STAT_P90_QUANTITY_NAME, "" ),
RifEclipseSummaryAddress::ensembleStatisticsAddress( ENSEMBLE_STAT_MEAN_QUANTITY_NAME, "" ) } );
}
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/FileInterface/RifReaderEclipseOutput.cpp
View File

@ -109,7 +109,7 @@
// vertex indices
//
static const size_t cellMappingECLRi[8] = {0, 1, 3, 2, 4, 5, 7, 6};
static const size_t cellMappingECLRi[8] = { 0, 1, 3, 2, 4, 5, 7, 6 };
//**************************************************************************************************
// Static functions

8
ApplicationCode/FileInterface/RifReaderEnsembleStatisticsRft.cpp
View File

@ -59,10 +59,10 @@ std::set<RifEclipseRftAddress> RifReaderEnsembleStatisticsRft::eclipseRftAddress
}
else if ( regularAddress.wellLogChannel() == RifEclipseRftAddress::PRESSURE )
{
std::set<RifEclipseRftAddress::RftWellLogChannelType> statChannels = {RifEclipseRftAddress::PRESSURE_P10,
RifEclipseRftAddress::PRESSURE_P50,
RifEclipseRftAddress::PRESSURE_P90,
RifEclipseRftAddress::PRESSURE_MEAN};
std::set<RifEclipseRftAddress::RftWellLogChannelType> statChannels = { RifEclipseRftAddress::PRESSURE_P10,
RifEclipseRftAddress::PRESSURE_P50,
RifEclipseRftAddress::PRESSURE_P90,
RifEclipseRftAddress::PRESSURE_MEAN };
for ( auto channel : statChannels )
{
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 );
if ( it != m_allWellObservations.end() )
{
return {it->second.dateTime};
return { it->second.dateTime };
}
return {};
}
@ -362,7 +362,7 @@ std::set<RifEclipseRftAddress::RftWellLogChannelType> RifReaderFmuRft::available
if ( !m_allWellObservations.empty() )
{
return {RifEclipseRftAddress::TVD, RifEclipseRftAddress::MD, RifEclipseRftAddress::PRESSURE};
return { RifEclipseRftAddress::TVD, RifEclipseRftAddress::MD, RifEclipseRftAddress::PRESSURE };
}
return {};
}

22
ApplicationCode/FileInterface/RifSurfaceImporter.cpp
View File

@ -83,9 +83,9 @@ void RifSurfaceImporter::readGocadFile( const QString& filename, RigGocadData* g
if ( firstToken.compare( "VRTX" ) == 0 )
{
int vertexId = -1;
double x{std::numeric_limits<double>::infinity()};
double y{std::numeric_limits<double>::infinity()};
double z{std::numeric_limits<double>::infinity()};
double x{ std::numeric_limits<double>::infinity() };
double y{ std::numeric_limits<double>::infinity() };
double z{ std::numeric_limits<double>::infinity() };
std::string endVertex;
lineStream >> vertexId >> x >> y >> z >> endVertex;
@ -104,9 +104,9 @@ void RifSurfaceImporter::readGocadFile( const QString& filename, RigGocadData* g
else if ( firstToken.compare( "PVRTX" ) == 0 )
{
int vertexId = -1;
double x{std::numeric_limits<double>::infinity()};
double y{std::numeric_limits<double>::infinity()};
double z{std::numeric_limits<double>::infinity()};
double x{ std::numeric_limits<double>::infinity() };
double y{ std::numeric_limits<double>::infinity() };
double z{ std::numeric_limits<double>::infinity() };
lineStream >> vertexId >> x >> y >> z;
@ -129,9 +129,9 @@ void RifSurfaceImporter::readGocadFile( const QString& filename, RigGocadData* g
}
else if ( firstToken.compare( "TRGL" ) == 0 )
{
int id1{-1};
int id2{-1};
int id3{-1};
int id1{ -1 };
int id2{ -1 };
int id3{ -1 };
lineStream >> id1 >> id2 >> id3;
@ -261,7 +261,7 @@ std::pair<std::vector<cvf::Vec3d>, std::vector<unsigned>> RifSurfaceImporter::re
// Add point
surfaceDataPoints.push_back( {i, j, {x, y, z}, values} );
surfaceDataPoints.push_back( { i, j, { x, y, z }, values } );
minI = std::min( minI, i );
minJ = std::min( minJ, j );
@ -440,7 +440,7 @@ std::pair<std::vector<cvf::Vec3d>, std::vector<unsigned>>
if ( z > 0.0 ) z = -z;
// Add point
surfacePoints.push_back( {x, y, z} );
surfacePoints.push_back( { x, y, z } );
if ( surfacePoints.size() > 1 )
{

2
ApplicationCode/GeoMech/GeoMechDataModel/RigFemPartGrid.cpp
View File

@ -284,7 +284,7 @@ cvf::Vec3i RigFemPartGrid::findMainIJKFaces( int elementIndex ) const
// Find the Z (for K) first. Then select among the other two the Y (for J),
// and select the remaining for I
int mainElmDirectionIdxForIJK[3] = {-1, -1, -1};
int mainElmDirectionIdxForIJK[3] = { -1, -1, -1 };
for ( int cIdx = 2; cIdx >= 0; --cIdx ) // Check Z first as it is more important
{
double maxAbsComp = -1.0;

8
ApplicationCode/GeoMech/GeoMechDataModel/RigFemPartResultCalculatorCompaction.cpp
View File

@ -200,10 +200,10 @@ void findReferenceElementForNode( const RigFemPart& part, size_t nodeIdx, size_t
{
cvf::ubyte faceNodes[4];
grid->cellFaceVertexIndices( intersection.m_face, faceNodes );
std::vector<size_t> topFaceCoords( {nodeIndices[faceNodes[0]],
nodeIndices[faceNodes[1]],
nodeIndices[faceNodes[2]],
nodeIndices[faceNodes[3]]} );
std::vector<size_t> topFaceCoords( { nodeIndices[faceNodes[0]],
nodeIndices[faceNodes[1]],
nodeIndices[faceNodes[2]],
nodeIndices[faceNodes[3]] } );
refElement->elementIdx = elemIdx;
refElement->intersectionPointToCurrentNodeDistance = nodeToIntersectionDistance;

12
ApplicationCode/GeoMech/GeoMechDataModel/RigFemPartResultCalculatorMudWeightWindow.cpp
View File

@ -70,12 +70,12 @@ RigFemScalarResultFrames* RigFemPartResultCalculatorMudWeightWindow::calculate(
CVF_ASSERT( isMatching( resVarAddr ) );
const std::vector<RimMudWeightWindowParameters::ParameterType> parameterTypes =
{RimMudWeightWindowParameters::ParameterType::WELL_DEVIATION,
RimMudWeightWindowParameters::ParameterType::WELL_AZIMUTH,
RimMudWeightWindowParameters::ParameterType::UCS,
RimMudWeightWindowParameters::ParameterType::POISSONS_RATIO,
RimMudWeightWindowParameters::ParameterType::K0_FG,
RimMudWeightWindowParameters::ParameterType::OBG0};
{ RimMudWeightWindowParameters::ParameterType::WELL_DEVIATION,
RimMudWeightWindowParameters::ParameterType::WELL_AZIMUTH,
RimMudWeightWindowParameters::ParameterType::UCS,
RimMudWeightWindowParameters::ParameterType::POISSONS_RATIO,
RimMudWeightWindowParameters::ParameterType::K0_FG,
RimMudWeightWindowParameters::ParameterType::OBG0 };
caf::ProgressInfo frameCountProgress( m_resultCollection->frameCount() * ( 5 + parameterTypes.size() ), "" );
frameCountProgress.setProgressDescription( "Calculating Mud Weight Window" );

20
ApplicationCode/GeoMech/GeoMechDataModel/RigFemPartResultsCollection.cpp
View File

@ -352,7 +352,7 @@ void RigFemPartResultsCollection::setBiotCoefficientParameters( double biotFixed
m_biotResultAddress = biotResultAddress;
// Invalidate all results which depends on biot coefficient (directly or indirectly)
for ( auto elementType : {RIG_ELEMENT_NODAL, RIG_INTEGRATION_POINT} )
for ( auto elementType : { RIG_ELEMENT_NODAL, RIG_INTEGRATION_POINT } )
{
deleteResult(
RigFemResultAddress( elementType, "COMPRESSIBILITY", "PORE", RigFemResultAddress::allTimeLapsesValue() ) );
@ -1246,8 +1246,8 @@ bool RigFemPartResultsCollection::isResultInSet( const RigFemResultAddress&
//--------------------------------------------------------------------------------------------------
std::set<RigFemResultAddress> RigFemPartResultsCollection::normalizedResults()
{
std::set<std::string> validFields = {"SE", "ST"};
std::set<std::string> validComponents = {"S11", "S22", "S33", "S12", "S13", "S23", "S1", "S2", "S3", "SM"};
std::set<std::string> validFields = { "SE", "ST" };
std::set<std::string> validComponents = { "S11", "S22", "S33", "S12", "S13", "S23", "S1", "S2", "S3", "SM" };
std::set<RigFemResultAddress> results;
for ( auto field : validFields )
@ -1282,7 +1282,7 @@ bool RigFemPartResultsCollection::isNormalizableResult( const RigFemResultAddres
std::set<RigFemResultAddress> RigFemPartResultsCollection::referenceCaseDependentResults()
{
std::set<RigFemResultAddress> results;
for ( auto elementType : {RIG_ELEMENT_NODAL, RIG_INTEGRATION_POINT} )
for ( auto elementType : { RIG_ELEMENT_NODAL, RIG_INTEGRATION_POINT } )
{
results.insert(
RigFemResultAddress( elementType, "COMPRESSIBILITY", "PORE", RigFemResultAddress::allTimeLapsesValue() ) );
@ -1306,7 +1306,7 @@ std::set<RigFemResultAddress> RigFemPartResultsCollection::referenceCaseDependen
std::set<RigFemResultAddress> RigFemPartResultsCollection::mudWeightWindowResults()
{
std::set<RigFemResultAddress> results;
for ( auto elmType : {RIG_ELEMENT_NODAL, RIG_INTEGRATION_POINT} )
for ( auto elmType : { RIG_ELEMENT_NODAL, RIG_INTEGRATION_POINT } )
{
results.insert( RigFemResultAddress( elmType, "MUD-WEIGHT", "MWW", RigFemResultAddress::allTimeLapsesValue() ) );
results.insert( RigFemResultAddress( elmType, "MUD-WEIGHT", "MWM", RigFemResultAddress::allTimeLapsesValue() ) );
@ -1323,7 +1323,7 @@ std::set<RigFemResultAddress> RigFemPartResultsCollection::mudWeightWindowResult
std::set<RigFemResultAddress> RigFemPartResultsCollection::initialPermeabilityDependentResults()
{
std::set<RigFemResultAddress> results;
for ( auto elementType : {RIG_ELEMENT_NODAL, RIG_INTEGRATION_POINT} )
for ( auto elementType : { RIG_ELEMENT_NODAL, RIG_INTEGRATION_POINT } )
{
results.insert( RigFemResultAddress( elementType, "PORO-PERM", "PHI", RigFemResultAddress::allTimeLapsesValue() ) );
results.insert( RigFemResultAddress( elementType, "PORO-PERM", "DPHI", RigFemResultAddress::allTimeLapsesValue() ) );
@ -1534,7 +1534,7 @@ const RigFemPartCollection* RigFemPartResultsCollection::parts() const
//--------------------------------------------------------------------------------------------------
std::vector<std::string> RigFemPartResultsCollection::getStressComponentNames( bool includeShear )
{
std::vector<std::string> componentNames = {"S11", "S22", "S33", "S1", "S2", "S3"};
std::vector<std::string> componentNames = { "S11", "S22", "S33", "S1", "S2", "S3" };
if ( includeShear )
{
componentNames.push_back( "S12" );
@ -1550,7 +1550,7 @@ std::vector<std::string> RigFemPartResultsCollection::getStressComponentNames( b
//--------------------------------------------------------------------------------------------------
std::vector<std::string> RigFemPartResultsCollection::getStressAnisotropyComponentNames()
{
return {"SA12", "SA13", "SA23"};
return { "SA12", "SA13", "SA23" };
}
//--------------------------------------------------------------------------------------------------
@ -1558,7 +1558,7 @@ std::vector<std::string> RigFemPartResultsCollection::getStressAnisotropyCompone
//--------------------------------------------------------------------------------------------------
std::vector<std::string> RigFemPartResultsCollection::getStressGradientComponentNames( bool includeShear )
{
std::vector<std::string> directions = {"X", "Y", "Z"};
std::vector<std::string> directions = { "X", "Y", "Z" };
std::vector<std::string> stressComponentNames = getStressComponentNames( includeShear );
std::vector<std::string> stressGradientComponentNames;
@ -1769,7 +1769,7 @@ void RigFemPartResultsCollection::setWaterDensityShearSlipIndicator( double wate
{
m_waterDensityShearSlipIndicator = waterDensity;
for ( auto elementType : {RIG_ELEMENT_NODAL, RIG_INTEGRATION_POINT} )
for ( auto elementType : { RIG_ELEMENT_NODAL, RIG_INTEGRATION_POINT } )
{
deleteResult( RigFemResultAddress( elementType, "ST", "DPN", RigFemResultAddress::allTimeLapsesValue() ) );
}

13
ApplicationCode/GeoMech/GeoMechDataModel/RigFemTypes.cpp
View File

@ -28,7 +28,7 @@
//--------------------------------------------------------------------------------------------------
int RigFemTypes::elementNodeCount( RigElementType elmType )
{
static int elementTypeCounts[3] = {8, 8, 4};
static int elementTypeCounts[3] = { 8, 8, 4 };
return elementTypeCounts[elmType];
}
@ -38,7 +38,7 @@ int RigFemTypes::elementNodeCount( RigElementType elmType )
//--------------------------------------------------------------------------------------------------
int RigFemTypes::elementFaceCount( RigElementType elmType )
{
const static int elementFaceCounts[3] = {6, 6, 1};
const static int elementFaceCounts[3] = { 6, 6, 1 };
return elementFaceCounts[elmType];
}
@ -58,8 +58,9 @@ int RigFemTypes::elementFaceCount( RigElementType elmType )
const int* RigFemTypes::localElmNodeIndicesForFace( RigElementType elmType, int faceIdx, int* faceNodeCount )
{
static const int HEX8_Faces[6][4] = {{1, 2, 6, 5}, {0, 4, 7, 3}, {3, 7, 6, 2}, {0, 1, 5, 4}, {4, 5, 6, 7}, {0, 3, 2, 1}};
static const int CAX4_Faces[4] = {0, 1, 2, 3};
static const int HEX8_Faces[6][4] =
{ { 1, 2, 6, 5 }, { 0, 4, 7, 3 }, { 3, 7, 6, 2 }, { 0, 1, 5, 4 }, { 4, 5, 6, 7 }, { 0, 3, 2, 1 } };
static const int CAX4_Faces[4] = { 0, 1, 2, 3 };
switch ( elmType )
{
@ -82,7 +83,7 @@ const int* RigFemTypes::localElmNodeIndicesForFace( RigElementType elmType, int
int RigFemTypes::oppositeFace( RigElementType elmType, int faceIdx )
{
static const int HEX8_OppositeFaces[6] = {1, 0, 3, 2, 5, 4};
static const int HEX8_OppositeFaces[6] = { 1, 0, 3, 2, 5, 4 };
switch ( elmType )
{
@ -107,7 +108,7 @@ int RigFemTypes::oppositeFace( RigElementType elmType, int faceIdx )
const int* RigFemTypes::localElmNodeToIntegrationPointMapping( RigElementType elmType )
{
static const int HEX8_Mapping[8] = {0, 1, 3, 2, 4, 5, 7, 6};
static const int HEX8_Mapping[8] = { 0, 1, 3, 2, 4, 5, 7, 6 };
switch ( elmType )
{

16
ApplicationCode/GeoMech/GeoMechDataModel/RigHexGradientTools.cpp
View File

@ -38,14 +38,14 @@ std::array<cvf::Vec3d, 8> RigHexGradientTools::gradients( const std::array<cvf::
gradientsUVW[7] = cvf::Vec3d( forwardFD( values, 7, 6 ), forwardFD( values, 4, 7 ), forwardFD( values, 3, 7 ) );
std::array<cvf::Vec3d, 8> NC;
NC[0] = {-1, -1, -1};
NC[1] = {1, -1, -1};
NC[2] = {1, 1, -1};
NC[3] = {-1, 1, -1};
NC[4] = {-1, -1, 1};
NC[5] = {1, -1, 1};
NC[6] = {1, 1, 1};
NC[7] = {-1, 1, 1};
NC[0] = { -1, -1, -1 };
NC[1] = { 1, -1, -1 };
NC[2] = { 1, 1, -1 };
NC[3] = { -1, 1, -1 };
NC[4] = { -1, -1, 1 };
NC[5] = { 1, -1, 1 };
NC[6] = { 1, 1, 1 };
NC[7] = { -1, 1, 1 };
std::array<cvf::Vec3d, 8> gradientsXYZ;

2
ApplicationCode/GeoMech/OdbReader/RifOdbReader.cpp
View File

@ -135,7 +135,7 @@ RigElementType toRigElementType( const odb_String& odbTypeName )
const int* localElmNodeToIntegrationPointMapping( RigElementType elmType )
{
static const int HEX8_Mapping[8] = {0, 1, 3, 2, 4, 5, 7, 6};
static const int HEX8_Mapping[8] = { 0, 1, 3, 2, 4, 5, 7, 6 };
switch ( elmType )
{

10
ApplicationCode/GrpcInterface/RiaGrpcAppService.cpp
View File

@ -64,11 +64,11 @@ grpc::Status
std::vector<RiaGrpcCallbackInterface*> RiaGrpcAppService::createCallbacks()
{
typedef RiaGrpcAppService Self;
return {new RiaGrpcUnaryCallback<Self, rips::Empty, rips::Version>( this, &Self::GetVersion, &Self::RequestGetVersion ),
new RiaGrpcUnaryCallback<Self, rips::Empty, rips::Empty>( this, &Self::Exit, &Self::RequestExit ),
new RiaGrpcUnaryCallback<Self, rips::Empty, rips::RuntimeInfo>( this,
&Self::GetRuntimeInfo,
&Self::RequestGetRuntimeInfo )};
return { new RiaGrpcUnaryCallback<Self, rips::Empty, rips::Version>( this, &Self::GetVersion, &Self::RequestGetVersion ),
new RiaGrpcUnaryCallback<Self, rips::Empty, rips::Empty>( this, &Self::Exit, &Self::RequestExit ),
new RiaGrpcUnaryCallback<Self, rips::Empty, rips::RuntimeInfo>( this,
&Self::GetRuntimeInfo,
&Self::RequestGetRuntimeInfo ) };
}
static bool RiaGrpcAppInfoService_init =

84
ApplicationCode/GrpcInterface/RiaGrpcCaseService.cpp
View File

@ -729,49 +729,49 @@ std::vector<RiaGrpcCallbackInterface*> RiaGrpcCaseService::createCallbacks()
{
typedef RiaGrpcCaseService Self;
return {new RiaGrpcUnaryCallback<Self, CaseRequest, GridCount>( this, &Self::GetGridCount, &Self::RequestGetGridCount ),
new RiaGrpcUnaryCallback<Self, CellInfoRequest, CellCount>( this, &Self::GetCellCount, &Self::RequestGetCellCount ),
new RiaGrpcUnaryCallback<Self, CaseRequest, TimeStepDates>( this, &Self::GetTimeSteps, &Self::RequestGetTimeSteps ),
new RiaGrpcUnaryCallback<Self, CaseRequest, DaysSinceStart>( this,
&Self::GetDaysSinceStart,
&Self::RequestGetDaysSinceStart ),
new RiaGrpcUnaryCallback<Self, CaseRequest, CaseInfo>( this, &Self::GetCaseInfo, &Self::RequestGetCaseInfo ),
new RiaGrpcUnaryCallback<Self, CaseRequest, PdmObject>( this, &Self::GetPdmObject, &Self::RequestGetPdmObject ),
new RiaGrpcServerToClientStreamCallback<Self,
CellInfoRequest,
CellInfoArray,
RiaActiveCellInfoStateHandler>( this,
&Self::GetCellInfoForActiveCells,
&Self::RequestGetCellInfoForActiveCells,
new RiaActiveCellInfoStateHandler ),
new RiaGrpcServerToClientStreamCallback<Self,
CellInfoRequest,
CellCenters,
RiaActiveCellInfoStateHandler>( this,
&Self::GetCellCenterForActiveCells,
&Self::RequestGetCellCenterForActiveCells,
new RiaActiveCellInfoStateHandler ),
new RiaGrpcServerToClientStreamCallback<Self,
CellInfoRequest,
CellCornersArray,
RiaActiveCellInfoStateHandler>( this,
&Self::GetCellCornersForActiveCells,
&Self::RequestGetCellCornersForActiveCells,
new RiaActiveCellInfoStateHandler ),
new RiaGrpcServerToClientStreamCallback<Self,
CaseRequest,
SelectedCells,
RiaSelectedCellsStateHandler>( this,
&Self::GetSelectedCells,
&Self::RequestGetSelectedCells,
new RiaSelectedCellsStateHandler ),
new RiaGrpcUnaryCallback<Self, CaseRequest, BoundingBox>( this,
&Self::GetReservoirBoundingBox,
&Self::RequestGetReservoirBoundingBox ),
return { new RiaGrpcUnaryCallback<Self, CaseRequest, GridCount>( this, &Self::GetGridCount, &Self::RequestGetGridCount ),
new RiaGrpcUnaryCallback<Self, CellInfoRequest, CellCount>( this, &Self::GetCellCount, &Self::RequestGetCellCount ),
new RiaGrpcUnaryCallback<Self, CaseRequest, TimeStepDates>( this, &Self::GetTimeSteps, &Self::RequestGetTimeSteps ),
new RiaGrpcUnaryCallback<Self, CaseRequest, DaysSinceStart>( this,
&Self::GetDaysSinceStart,
&Self::RequestGetDaysSinceStart ),
new RiaGrpcUnaryCallback<Self, CaseRequest, CaseInfo>( this, &Self::GetCaseInfo, &Self::RequestGetCaseInfo ),
new RiaGrpcUnaryCallback<Self, CaseRequest, PdmObject>( this, &Self::GetPdmObject, &Self::RequestGetPdmObject ),
new RiaGrpcServerToClientStreamCallback<Self,
CellInfoRequest,
CellInfoArray,
RiaActiveCellInfoStateHandler>( this,
&Self::GetCellInfoForActiveCells,
&Self::RequestGetCellInfoForActiveCells,
new RiaActiveCellInfoStateHandler ),
new RiaGrpcServerToClientStreamCallback<Self,
CellInfoRequest,
CellCenters,
RiaActiveCellInfoStateHandler>( this,
&Self::GetCellCenterForActiveCells,
&Self::RequestGetCellCenterForActiveCells,
new RiaActiveCellInfoStateHandler ),
new RiaGrpcServerToClientStreamCallback<Self,
CellInfoRequest,
CellCornersArray,
RiaActiveCellInfoStateHandler>( this,
&Self::GetCellCornersForActiveCells,
&Self::RequestGetCellCornersForActiveCells,
new RiaActiveCellInfoStateHandler ),
new RiaGrpcServerToClientStreamCallback<Self,
CaseRequest,
SelectedCells,
RiaSelectedCellsStateHandler>( this,
&Self::GetSelectedCells,
&Self::RequestGetSelectedCells,
new RiaSelectedCellsStateHandler ),
new RiaGrpcUnaryCallback<Self, CaseRequest, BoundingBox>( this,
&Self::GetReservoirBoundingBox,
&Self::RequestGetReservoirBoundingBox ),
new RiaGrpcUnaryCallback<Self, CaseRequest, CoarseningInfoArray>( this,
&Self::GetCoarseningInfoArray,
&Self::RequestGetCoarseningInfoArray )};
new RiaGrpcUnaryCallback<Self, CaseRequest, CoarseningInfoArray>( this,
&Self::GetCoarseningInfoArray,
&Self::RequestGetCoarseningInfoArray ) };
}
static bool RiaGrpcCaseService_init =

2
ApplicationCode/GrpcInterface/RiaGrpcCommandService.cpp
View File

@ -106,7 +106,7 @@ std::vector<RiaGrpcCallbackInterface*> RiaGrpcCommandService::createCallbacks()
{
typedef RiaGrpcCommandService Self;
return {new RiaGrpcUnaryCallback<Self, CommandParams, CommandReply>( this, &Self::Execute, &Self::RequestExecute )};
return { new RiaGrpcUnaryCallback<Self, CommandParams, CommandReply>( this, &Self::Execute, &Self::RequestExecute ) };
}
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/GrpcInterface/RiaGrpcGridService.cpp
View File

@ -201,7 +201,7 @@ std::vector<RiaGrpcCallbackInterface*> RiaGrpcGridService::createCallbacks()
&Self::RequestGetCellCorners,
new RiaCellCenterStateHandler ),
new RiaGrpcUnaryCallback<Self, GridRequest, GridDimensions>( this, &Self::GetDimensions, &Self::RequestGetDimensions )};
new RiaGrpcUnaryCallback<Self, GridRequest, GridDimensions>( this, &Self::GetDimensions, &Self::RequestGetDimensions ) };
}
static bool RiaGrpcGridService_init =

49
ApplicationCode/GrpcInterface/RiaGrpcNNCPropertiesService.cpp
View File

@ -496,31 +496,32 @@ std::vector<RiaGrpcCallbackInterface*> RiaGrpcNNCPropertiesService::createCallba
std::vector<RiaGrpcCallbackInterface*> callbacks;
callbacks =
{new RiaGrpcUnaryCallback<Self, CaseRequest, AvailableNNCProperties>( this,
&Self::GetAvailableNNCProperties,
&Self::RequestGetAvailableNNCProperties ),
new RiaGrpcServerToClientStreamCallback<Self,
CaseRequest,
rips::NNCConnections,
RiaNNCConnectionsStateHandler>( this,
&Self::GetNNCConnections,
&Self::RequestGetNNCConnections,
new RiaNNCConnectionsStateHandler ),
new RiaGrpcServerToClientStreamCallback<Self,
NNCValuesRequest,
rips::NNCValues,
RiaNNCValuesStateHandler>( this,
&Self::GetNNCValues,
&Self::RequestGetNNCValues,
new RiaNNCValuesStateHandler ),
{ new RiaGrpcUnaryCallback<Self, CaseRequest, AvailableNNCProperties>( this,
&Self::GetAvailableNNCProperties,
&Self::RequestGetAvailableNNCProperties ),
new RiaGrpcServerToClientStreamCallback<Self,
CaseRequest,
rips::NNCConnections,
RiaNNCConnectionsStateHandler>( this,
&Self::GetNNCConnections,
&Self::RequestGetNNCConnections,
new RiaNNCConnectionsStateHandler ),
new RiaGrpcServerToClientStreamCallback<Self,
NNCValuesRequest,
rips::NNCValues,
RiaNNCValuesStateHandler>( this,
&Self::GetNNCValues,
&Self::RequestGetNNCValues,
new RiaNNCValuesStateHandler ),
new RiaGrpcClientToServerStreamCallback<Self,
NNCValuesChunk,
ClientToServerStreamReply,
RiaNNCInputValuesStateHandler>( this,
&Self::SetNNCValues,
&Self::RequestSetNNCValues,
new RiaNNCInputValuesStateHandler( true ) )};
new RiaGrpcClientToServerStreamCallback<Self,
NNCValuesChunk,
ClientToServerStreamReply,
RiaNNCInputValuesStateHandler>( this,
&Self::SetNNCValues,
&Self::RequestSetNNCValues,
new RiaNNCInputValuesStateHandler(
true ) ) };
return callbacks;
}

18
ApplicationCode/GrpcInterface/RiaGrpcProjectService.cpp
View File

@ -204,14 +204,16 @@ std::vector<RiaGrpcCallbackInterface*> RiaGrpcProjectService::createCallbacks()
{
typedef RiaGrpcProjectService Self;
return {new RiaGrpcUnaryCallback<Self, Empty, CaseRequest>( this, &Self::GetCurrentCase, &Self::RequestGetCurrentCase ),
new RiaGrpcUnaryCallback<Self, Empty, CaseInfoArray>( this, &Self::GetSelectedCases, &Self::RequestGetSelectedCases ),
new RiaGrpcUnaryCallback<Self, Empty, CaseGroups>( this, &Self::GetAllCaseGroups, &Self::RequestGetAllCaseGroups ),
new RiaGrpcUnaryCallback<Self, Empty, CaseInfoArray>( this, &Self::GetAllCases, &Self::RequestGetAllCases ),
new RiaGrpcUnaryCallback<Self, CaseGroup, CaseInfoArray>( this,
&Self::GetCasesInGroup,
&Self::RequestGetCasesInGroup ),
new RiaGrpcUnaryCallback<Self, Empty, PdmObject>( this, &Self::GetPdmObject, &Self::RequestGetPdmObject )};
return { new RiaGrpcUnaryCallback<Self, Empty, CaseRequest>( this, &Self::GetCurrentCase, &Self::RequestGetCurrentCase ),
new RiaGrpcUnaryCallback<Self, Empty, CaseInfoArray>( this,
&Self::GetSelectedCases,
&Self::RequestGetSelectedCases ),
new RiaGrpcUnaryCallback<Self, Empty, CaseGroups>( this, &Self::GetAllCaseGroups, &Self::RequestGetAllCaseGroups ),
new RiaGrpcUnaryCallback<Self, Empty, CaseInfoArray>( this, &Self::GetAllCases, &Self::RequestGetAllCases ),
new RiaGrpcUnaryCallback<Self, CaseGroup, CaseInfoArray>( this,
&Self::GetCasesInGroup,
&Self::RequestGetCasesInGroup ),
new RiaGrpcUnaryCallback<Self, Empty, PdmObject>( this, &Self::GetPdmObject, &Self::RequestGetPdmObject ) };
}
static bool RiaGrpcProjectService_init = RiaGrpcServiceFactory::instance()->registerCreator<RiaGrpcProjectService>(

38
ApplicationCode/GrpcInterface/RiaGrpcPropertiesService.cpp
View File

@ -461,25 +461,25 @@ std::vector<RiaGrpcCallbackInterface*> RiaGrpcPropertiesService::createCallbacks
std::vector<RiaGrpcCallbackInterface*> callbacks;
callbacks =
{new RiaGrpcUnaryCallback<Self, AvailablePropertiesRequest, AvailableProperties>( this,
&Self::GetAvailableProperties,
&Self::RequestGetAvailableProperties ),
new RiaGrpcClientToServerStreamCallback<Self,
PropertyInputChunk,
ClientToServerStreamReply,
RiaActiveCellResultsStateHandler>( this,
&Self::SetActiveCellProperty,
&Self::RequestSetActiveCellProperty,
new RiaActiveCellResultsStateHandler(
true ) ),
new RiaGrpcClientToServerStreamCallback<Self,
PropertyInputChunk,
ClientToServerStreamReply,
RiaGridCellResultsStateHandler>( this,
&Self::SetGridProperty,
&Self::RequestSetGridProperty,
new RiaGridCellResultsStateHandler(
true ) )};
{ new RiaGrpcUnaryCallback<Self, AvailablePropertiesRequest, AvailableProperties>( this,
&Self::GetAvailableProperties,
&Self::RequestGetAvailableProperties ),
new RiaGrpcClientToServerStreamCallback<Self,
PropertyInputChunk,
ClientToServerStreamReply,
RiaActiveCellResultsStateHandler>( this,
&Self::SetActiveCellProperty,
&Self::RequestSetActiveCellProperty,
new RiaActiveCellResultsStateHandler(
true ) ),
new RiaGrpcClientToServerStreamCallback<Self,
PropertyInputChunk,
ClientToServerStreamReply,
RiaGridCellResultsStateHandler>( this,
&Self::SetGridProperty,
&Self::RequestSetGridProperty,
new RiaGridCellResultsStateHandler(
true ) ) };
for ( int i = 0; i < NUM_CONCURRENT_CLIENT_TO_SERVER_STREAMS; ++i )
{

4
ApplicationCode/ModelVisualization/Intersections/RivBoxIntersectionGeometryGenerator.cpp
View File

@ -212,8 +212,8 @@ public:
std::array<FaceType, 4> adjacentFaces( FaceType face )
{
std::array<FaceType, 4> clipFaces = {FaceType::NO_FACE, FaceType::NO_FACE, FaceType::NO_FACE, FaceType::NO_FACE};
FaceType oppFace = cvf::StructGridInterface::oppositeFace( face );
std::array<FaceType, 4> clipFaces = { FaceType::NO_FACE, FaceType::NO_FACE, FaceType::NO_FACE, FaceType::NO_FACE };
FaceType oppFace = cvf::StructGridInterface::oppositeFace( face );
int clipFaceCount = 0;
for ( int faceCand = 0; faceCand < 6; ++faceCand )
{

10
ApplicationCode/ModelVisualization/Intersections/RivExtrudedCurveIntersectionGeometryGenerator.cpp
View File

@ -188,7 +188,7 @@ public:
{
cvf::Vec3d highestVx = p0.z() > p1.z() ? p0 : p1;
auto itIsInsertedPair = faultToHighestFaultMeshVxMap.insert( {fault, highestVx} );
auto itIsInsertedPair = faultToHighestFaultMeshVxMap.insert( { fault, highestVx } );
if ( !itIsInsertedPair.second )
{
if ( itIsInsertedPair.first->second.z() < highestVx.z() )
@ -430,7 +430,7 @@ void RivExtrudedCurveIntersectionGeometryGenerator::calculateArrays()
for ( const auto& it : meshAcc.faultToHighestFaultMeshVxMap )
{
m_faultMeshLabelAndAnchorPositions.push_back( {it.first->name(), it.second} );
m_faultMeshLabelAndAnchorPositions.push_back( { it.first->name(), it.second } );
}
}
@ -508,7 +508,8 @@ cvf::ref<cvf::DrawableGeo> RivExtrudedCurveIntersectionGeometryGenerator::create
displayCoords.push_back( transform->translateToDisplayCoord( pt ) );
}
return RivPolylineGenerator::createLineAlongPolylineDrawable( std::vector<std::vector<cvf::Vec3d>>( {displayCoords} ) );
return RivPolylineGenerator::createLineAlongPolylineDrawable(
std::vector<std::vector<cvf::Vec3d>>( { displayCoords } ) );
}
//--------------------------------------------------------------------------------------------------
@ -533,7 +534,8 @@ cvf::ref<cvf::DrawableGeo> RivExtrudedCurveIntersectionGeometryGenerator::create
displayCoords.push_back( transform->translateToDisplayCoord( pt ) );
}
return RivPolylineGenerator::createPointsFromPolylineDrawable( std::vector<std::vector<cvf::Vec3d>>( {displayCoords} ) );
return RivPolylineGenerator::createPointsFromPolylineDrawable(
std::vector<std::vector<cvf::Vec3d>>( { displayCoords } ) );
}
//--------------------------------------------------------------------------------------------------

6
ApplicationCode/ModelVisualization/RivReachCircleAnnotationPartMgr.cpp
View File

@ -105,9 +105,9 @@ void RivReachCircleAnnotationPartMgr::buildParts( const caf::DisplayCoordTransfo
double yMin = centerPos.y() - symbolSize / 2.0;
double yMax = yMin + symbolSize;
double z = centerPos.z();
std::vector<Vec3d> line1 = {{xMin, yMin, z}, {xMax, yMax, z}};
std::vector<Vec3d> line2 = {{xMax, yMin, z}, {xMin, yMax, z}};
std::vector<std::vector<Vec3d>> symbol = {line1, line2};
std::vector<Vec3d> line1 = { { xMin, yMin, z }, { xMax, yMax, z } };
std::vector<Vec3d> line2 = { { xMax, yMin, z }, { xMin, yMax, z } };
std::vector<std::vector<Vec3d>> symbol = { line1, line2 };
cvf::ref<cvf::DrawableGeo> drawableGeo = RivPolylineGenerator::createLineAlongPolylineDrawable( symbol );
cvf::ref<cvf::Part> part = new cvf::Part;

10
ApplicationCode/ModelVisualization/RivReservoirFaultsPartMgr.cpp
View File

@ -175,11 +175,11 @@ void RivReservoirFaultsPartMgr::appendPartsToModel( cvf::ModelBasicList* model )
}
{
QStringList stringsToMatch{RiaDefines::combinedRiTranResultName(),
RiaDefines::combinedRiMultResultName(),
RiaDefines::combinedRiAreaNormTranResultName(),
RiaDefines::combinedTransmissibilityResultName(),
RiaDefines::combinedMultResultName()};
QStringList stringsToMatch{ RiaDefines::combinedRiTranResultName(),
RiaDefines::combinedRiMultResultName(),
RiaDefines::combinedRiAreaNormTranResultName(),
RiaDefines::combinedTransmissibilityResultName(),
RiaDefines::combinedMultResultName() };
for ( const auto& s : stringsToMatch )
{

4
ApplicationCode/ModelVisualization/RivSimWellPipesPartMgr.cpp
View File

@ -175,7 +175,7 @@ void RivSimWellPipesPartMgr::buildWellPipeParts( const caf::DisplayCoordTransfor
cvf::Vec3d flattenedStartOffset = cvf::Vec3d::ZERO;
if ( m_pipeBranchesCLCoords.size() > branchIdxStart && m_pipeBranchesCLCoords[branchIdxStart].size() )
{
flattenedStartOffset = {0.0, 0.0, m_pipeBranchesCLCoords[branchIdxStart][0].z()};
flattenedStartOffset = { 0.0, 0.0, m_pipeBranchesCLCoords[branchIdxStart][0].z() };
}
for ( size_t brIdx = branchIdxStart; brIdx < branchIdxStop; ++brIdx )
@ -351,7 +351,7 @@ void RivSimWellPipesPartMgr::buildWellPipeParts( const caf::DisplayCoordTransfor
}
}
if ( doFlatten ) flattenedStartOffset += {2 * flattenedIntersectionExtentLength, 0.0, 0.0};
if ( doFlatten ) flattenedStartOffset += { 2 * flattenedIntersectionExtentLength, 0.0, 0.0 };
}
}

2
ApplicationCode/ModelVisualization/RivTensorResultPartMgr.cpp
View File

@ -407,7 +407,7 @@ void RivTensorResultPartMgr::createOneColorPerPrincipalScalarMapper( const RimTe
// Using a linear color mapper to set colors for three discrete principal numbers (1, 2, 3)
// by setting the 3 + 1 interval levels so the principal numbers match the center of the intervals.
std::set<double> levelValues = {0.5, 1.5, 2.5, 3.5};
std::set<double> levelValues = { 0.5, 1.5, 2.5, 3.5 };
scalarMapper->setLevelsFromValues( levelValues );
}

2
ApplicationCode/ModelVisualization/RivTernarySaturationOverlayItem.cpp
View File

@ -254,5 +254,5 @@ void RivTernarySaturationOverlayItem::setRangeText( const cvf::String& soilRange
//--------------------------------------------------------------------------------------------------
cvf::Vec2ui RivTernarySaturationOverlayItem::preferredSize()
{
return {140, 180}; // Could do more elaborate text width checks.
return { 140, 180 }; // Could do more elaborate text width checks.
}

2
ApplicationCode/ModelVisualization/RivTextAnnotationPartMgr.cpp
View File

@ -98,7 +98,7 @@ void RivTextAnnotationPartMgr::buildParts( const caf::DisplayCoordTransform* dis
// Line part
{
std::vector<cvf::Vec3d> points = {anchorPosition, labelPosition};
std::vector<cvf::Vec3d> points = { anchorPosition, labelPosition };
cvf::ref<cvf::DrawableGeo> drawableGeo = RivPolylineGenerator::createLineAlongPolylineDrawable( points );

14
ApplicationCode/ModelVisualization/RivWellConnectionsPartMgr.cpp
View File

@ -267,14 +267,14 @@ cvf::ref<cvf::DrawableGeo> RivWellConnectionsPartMgr::createArrowGeometry( const
// : flat : : : : : : : : end 18 18
// 1 3 5 7 9 11 19 13 15 17 17
static const cvf::uint producerArrowFaceList[8 * 5 + 4] = {4, 0, 1, 3, 2, 4, 2, 3, 5, 4, 4, 4, 5, 7, 6,
4, 6, 7, 9, 8, 4, 8, 9, 11, 10, 4, 10, 11, 20, 19,
4, 19, 20, 13, 12, 4, 12, 13, 15, 14, 3, 16, 17, 18};
static const cvf::uint producerArrowFaceList[8 * 5 + 4] = { 4, 0, 1, 3, 2, 4, 2, 3, 5, 4, 4, 4, 5, 7, 6,
4, 6, 7, 9, 8, 4, 8, 9, 11, 10, 4, 10, 11, 20, 19,
4, 19, 20, 13, 12, 4, 12, 13, 15, 14, 3, 16, 17, 18 };
static const cvf::uint injectorArrowFaceList[8 * 5 + 8] = {4, 0, 1, 3, 2, 4, 2, 3, 5, 4, 4, 4,
5, 7, 6, 4, 6, 7, 9, 8, 4, 8, 9, 11,
10, 4, 10, 11, 20, 19, 4, 19, 20, 13, 12, 4,
12, 13, 15, 14, 3, 14, 18, 16, 3, 18, 15, 17};
static const cvf::uint injectorArrowFaceList[8 * 5 + 8] = { 4, 0, 1, 3, 2, 4, 2, 3, 5, 4, 4, 4,
5, 7, 6, 4, 6, 7, 9, 8, 4, 8, 9, 11,
10, 4, 10, 11, 20, 19, 4, 19, 20, 13, 12, 4,
12, 13, 15, 14, 3, 14, 18, 16, 3, 18, 15, 17 };
cvf::Vec3f endPointInTopPlane = endPoint;
if ( m_useCurvedArrows ) endPointInTopPlane.z() = startPoint.z();

6
ApplicationCode/ModelVisualization/RivWellDiskPartMgr.cpp
View File

@ -183,9 +183,9 @@ void RivWellDiskPartMgr::buildWellDiskParts( size_t frameIndex, const caf::Displ
cvf::ref<cvf::Effect> effectToUse = RiaGuiApplication::instance()->useShaders() ? m_shaderEffect : m_fixedFuncEffect;
const cvf::Color3ub colorTable[] = {cvf::Color3ub( 0, 177, 89 ), // Green
cvf::Color3ub( 255, 66, 66 ), // Red
cvf::Color3ub( 66, 66, 255 )}; // Blue
const cvf::Color3ub colorTable[] = { cvf::Color3ub( 0, 177, 89 ), // Green
cvf::Color3ub( 255, 66, 66 ), // Red
cvf::Color3ub( 66, 66, 255 ) }; // Blue
size_t vertexCount = geo1->vertexCount();
cvf::ref<cvf::Color3ubArray> colorArray = new cvf::Color3ubArray;

30
ApplicationCode/ModelVisualization/RivWellPathPartMgr.cpp
View File

@ -466,9 +466,9 @@ void RivWellPathPartMgr::appendPerforationsToModel( cvf::ModelBasicList*
vector<cvf::Mat4d> flatningCSs =
RivSectionFlattner::calculateFlatteningCSsForPolyline( perfIntervalCL,
cvf::Vec3d::Z_AXIS,
{horizontalLengthAlongWellPath,
0.0,
perfIntervalCL[0].z()},
{ horizontalLengthAlongWellPath,
0.0,
perfIntervalCL[0].z() },
&dummy );
for ( size_t cIdx = 0; cIdx < perfIntervalCL.size(); ++cIdx )
@ -520,15 +520,15 @@ void RivWellPathPartMgr::appendPerforationValvesToModel( cvf::ModelBasicList*
cvf::Color3f valveColor = valve->defaultComponentColor();
if ( valve->componentType() == RiaDefines::WellPathComponentType::ICV )
{
measuredDepthsRelativeToStartMD = {0.0, 1.0, 1.5, 4.0, 5.0, 5.5, 8.0, 9.0};
radii = {wellPathRadius,
wellPathRadius * 1.8,
wellPathRadius * 2.0,
wellPathRadius * 2.0,
wellPathRadius * 1.8,
wellPathRadius * 1.7,
wellPathRadius * 1.7,
wellPathRadius};
measuredDepthsRelativeToStartMD = { 0.0, 1.0, 1.5, 4.0, 5.0, 5.5, 8.0, 9.0 };
radii = { wellPathRadius,
wellPathRadius * 1.8,
wellPathRadius * 2.0,
wellPathRadius * 2.0,
wellPathRadius * 1.8,
wellPathRadius * 1.7,
wellPathRadius * 1.7,
wellPathRadius };
double startMD = valve->startMD();
std::vector<cvf::Vec3d> displayCoords;
@ -696,9 +696,9 @@ void RivWellPathPartMgr::buildWellPathParts( const caf::DisplayCoordTransform* d
std::vector<cvf::Mat4d> flatningCSs =
RivSectionFlattner::calculateFlatteningCSsForPolyline( clippedWellPathCenterLine,
cvf::Vec3d::Z_AXIS,
{horizontalLengthAlongWellToClipPoint,
0.0,
clippedWellPathCenterLine[0].z()},
{ horizontalLengthAlongWellToClipPoint,
0.0,
clippedWellPathCenterLine[0].z() },
&dummy );
for ( size_t cIdx = 0; cIdx < cvfCoords->size(); ++cIdx )

4
ApplicationCode/ModelVisualization/Surfaces/RivSurfaceIntersectionGeometryGenerator.cpp
View File

@ -110,7 +110,7 @@ public:
{
cvf::Vec3d highestVx = p0.z() > p1.z() ? p0 : p1;
auto itIsInsertedPair = faultToHighestFaultMeshVxMap.insert( {fault, highestVx} );
auto itIsInsertedPair = faultToHighestFaultMeshVxMap.insert( { fault, highestVx } );
if ( !itIsInsertedPair.second )
{
if ( itIsInsertedPair.first->second.z() < highestVx.z() )
@ -309,7 +309,7 @@ void RivSurfaceIntersectionGeometryGenerator::calculateArrays()
for ( const auto& it : meshAcc.faultToHighestFaultMeshVxMap )
{
m_faultMeshLabelAndAnchorPositions.push_back( {it.first->name(), it.second} );
m_faultMeshLabelAndAnchorPositions.push_back( { it.first->name(), it.second } );
}
}

10
ApplicationCode/ModelVisualization/WindowEdgeAxesOverlayItem/RivWindowEdgeAxesOverlayItem.cpp
View File

@ -73,7 +73,7 @@ RivWindowEdgeAxesOverlayItem::RivWindowEdgeAxesOverlayItem( Font* font )
CVF_ASSERT( font );
CVF_ASSERT( !font->isEmpty() );
setLayoutFixedPosition( {0, 0} );
setLayoutFixedPosition( { 0, 0 } );
updateGeomerySizes();
}
@ -561,8 +561,8 @@ void RivWindowEdgeAxesOverlayItem::renderShaderFrameAndTickLines( OpenGLContext*
// Triangle indices for the frame background
static const ushort backgroundTriangleIndices[] = {0, 1, 5, 0, 5, 4, 1, 2, 6, 1, 6, 5,
3, 0, 4, 3, 4, 7, 2, 3, 6, 3, 7, 6};
static const ushort backgroundTriangleIndices[] = { 0, 1, 5, 0, 5, 4, 1, 2, 6, 1, 6, 5,
3, 0, 4, 3, 4, 7, 2, 3, 6, 3, 7, 6 };
glDrawRangeElements( GL_TRIANGLES, 0, 7, 24, GL_UNSIGNED_SHORT, backgroundTriangleIndices );
@ -571,13 +571,13 @@ void RivWindowEdgeAxesOverlayItem::renderShaderFrameAndTickLines( OpenGLContext*
UniformFloat uniformColor( "u_color", Color4f( m_lineColor, m_showAxisLines ? 0.25f : 1.0f ) );
shaderProgram->applyUniform( oglContext, uniformColor );
static const ushort frameLineIndices[] = {7, 4, 4, 5, 5, 6, 6, 7};
static const ushort frameLineIndices[] = { 7, 4, 4, 5, 5, 6, 6, 7 };
glDrawRangeElements( GL_LINES, 0, 7, 8, GL_UNSIGNED_SHORT, frameLineIndices );
// Render tickmarks
static const ushort tickLineIndices[] = {0, 1};
static const ushort tickLineIndices[] = { 0, 1 };
// X - axis Tick lines

30
ApplicationCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlot.cpp
View File

@ -486,8 +486,8 @@ void RimAnalysisPlot::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering
{
caf::PdmUiGroup* selVectorsGrp = uiOrdering.addNewGroup( "Selected Vectors" );
selVectorsGrp->add( &m_selectedVarsUiField );
selVectorsGrp->add( &m_selectVariablesButtonField, {false} );
selVectorsGrp->add( &m_referenceCase, {true, 3, 2} );
selVectorsGrp->add( &m_selectVariablesButtonField, { false } );
selVectorsGrp->add( &m_referenceCase, { true, 3, 2 } );
QString vectorNames;
if ( getOrCreateSelectedCurveDefAnalyser() )
@ -518,22 +518,22 @@ void RimAnalysisPlot::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering
caf::PdmUiGroup* titleGrp = uiOrdering.addNewGroup( "Title and Legend" );
titleGrp->add( &m_showPlotTitle );
titleGrp->add( &m_useAutoPlotTitle, {false} );
titleGrp->add( &m_description, {false} );
titleGrp->add( &m_useAutoPlotTitle, { false } );
titleGrp->add( &m_description, { false } );
m_description.uiCapability()->setUiReadOnly( m_useAutoPlotTitle() );
titleGrp->add( &m_showPlotLegends );
titleGrp->add( &m_legendFontSize );
m_legendFontSize.uiCapability()->setUiReadOnly( !m_showPlotLegends() );
caf::PdmUiGroup* chartSettings = uiOrdering.addNewGroup( "Bar Settings" );
chartSettings->add( &m_barOrientation, {true, 3, 2} );
chartSettings->add( &m_barOrientation, { true, 3, 2 } );
chartSettings->add( &m_majorGroupType );
chartSettings->add( &m_mediumGroupType );
chartSettings->add( &m_minorGroupType );
chartSettings->add( &m_valueSortOperation );
chartSettings->add( &m_useTopBarsFilter );
chartSettings->add( &m_maxBarCount, {false} );
chartSettings->add( &m_maxBarCount, { false } );
m_maxBarCount.uiCapability()->setUiReadOnly( !m_useTopBarsFilter() );
chartSettings->add( &m_sortGroupForColors );
@ -690,7 +690,7 @@ QList<caf::PdmOptionItemInfo> RimAnalysisPlot::calculateValueOptions( const caf:
{
std::vector<RimSummaryCase*> allSummaryCases = RimProject::current()->allSummaryCases();
options.push_back( {"None", nullptr} );
options.push_back( { "None", nullptr } );
for ( auto sumCase : allSummaryCases )
{
@ -701,7 +701,7 @@ QList<caf::PdmOptionItemInfo> RimAnalysisPlot::calculateValueOptions( const caf:
displayName = caseColl->name() + "/" + displayName;
}
options.push_back( {displayName, sumCase} );
options.push_back( { displayName, sumCase } );
}
}
else if ( fieldNeedingOptions == &m_barTextFontSize )
@ -1139,7 +1139,7 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem* filter,
{
bool useLargest = filter->filterOperation() == RimPlotDataFilterItem::TOP_N;
auto itIsInsertedPair = casesToKeepWithValue.insert( {sumCase, value} );
auto itIsInsertedPair = casesToKeepWithValue.insert( { sumCase, value } );
if ( !itIsInsertedPair.second ) // Already exists in map
{
double& insertedValue = itIsInsertedPair.first->second;
@ -1239,7 +1239,7 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem* filter,
if ( historyTimesteps.size() )
{
selectedTimestepIndices =
RimAnalysisPlot::findTimestepIndices( {historyTimesteps.back()}, timesteps );
RimAnalysisPlot::findTimestepIndices( { historyTimesteps.back() }, timesteps );
}
}
else if ( filter->consideredTimeStepsType() == RimPlotDataFilterItem::SELECT_TIMESTEP_RANGE )
@ -1294,7 +1294,7 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem* filter,
{
bool useLargest = filter->filterOperation() == RimPlotDataFilterItem::TOP_N;
auto itIsInsertedPair = casesToKeepWithValue.insert( {sumCaseInEvaluation, value} );
auto itIsInsertedPair = casesToKeepWithValue.insert( { sumCaseInEvaluation, value } );
if ( !itIsInsertedPair.second ) // Already exists in map
{
double& insertedValue = itIsInsertedPair.first->second;
@ -1345,7 +1345,7 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem* filter,
{
bool useLargest = filter->filterOperation() == RimPlotDataFilterItem::TOP_N;
auto itIsInsertedPair = sumItemsToKeepWithValue.insert( {sumItem, value} );
auto itIsInsertedPair = sumItemsToKeepWithValue.insert( { sumItem, value } );
if ( !itIsInsertedPair.second ) // Already exists in map
{
double& insertedValue = itIsInsertedPair.first->second;
@ -1373,7 +1373,7 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem* filter,
std::multimap<double, RifEclipseSummaryAddress> valueSortedSumItems;
for ( const auto& itemValPair : sumItemsToKeepWithValue )
{
valueSortedSumItems.insert( {itemValPair.second, itemValPair.first} );
valueSortedSumItems.insert( { itemValPair.second, itemValPair.first } );
}
if ( filter->filterOperation() == RimPlotDataFilterItem::TOP_N )
@ -1404,7 +1404,7 @@ void RimAnalysisPlot::applyFilter( const RimPlotDataFilterItem* filter,
std::multimap<double, RimSummaryCase*> valueSortedSumCases;
for ( const auto& caseValPair : casesToKeepWithValue )
{
valueSortedSumCases.insert( {caseValPair.second, caseValPair.first} );
valueSortedSumCases.insert( { caseValPair.second, caseValPair.first } );
}
if ( filter->filterOperation() == RimPlotDataFilterItem::TOP_N )
@ -1701,7 +1701,7 @@ std::vector<RiaSummaryCurveDefinition> RimAnalysisPlot::curveDefinitions() const
//--------------------------------------------------------------------------------------------------
std::set<RimPlotAxisPropertiesInterface*> RimAnalysisPlot::allPlotAxes() const
{
return {m_valueAxisProperties};
return { m_valueAxisProperties };
}
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/ProjectDataModel/AnalysisPlots/RimAnalysisPlotCollection.cpp
View File

@ -89,7 +89,7 @@ RimAnalysisPlot* RimAnalysisPlotCollection::createAnalysisPlot( RimSummaryCaseCo
plot->setAsPlotMdiWindow();
applySummaryCaseCollectionAndFieldAddressToPlot( plot, ensemble, quantityName.toStdString() );
plot->setTimeSteps( {timeStep} );
plot->setTimeSteps( { timeStep } );
// plot->enableAutoPlotTitle( true );
addPlot( plot );

16
ApplicationCode/ProjectDataModel/AnalysisPlots/RimPlotDataFilterItem.cpp
View File

@ -338,19 +338,19 @@ void RimPlotDataFilterItem::defineUiOrdering( QString uiConfigName, caf::PdmUiOr
updateMaxMinAndDefaultValues( false );
uiOrdering.add( &m_filterTarget, {true, -1, 1} );
uiOrdering.add( &m_filterTarget, { true, -1, 1 } );
if ( m_filterTarget() == ENSEMBLE_CASE )
{
uiOrdering.add( &m_filterEnsembleParameter, {true, caf::PdmUiOrdering::LayoutOptions::MAX_COLUMN_SPAN, 1} );
uiOrdering.add( &m_filterEnsembleParameter, { true, caf::PdmUiOrdering::LayoutOptions::MAX_COLUMN_SPAN, 1 } );
}
else
{
uiOrdering.add( &m_filterQuantityUiField, {true, caf::PdmUiOrdering::LayoutOptions::MAX_COLUMN_SPAN, 1} );
uiOrdering.add( &m_filterQuantityUiField, { true, caf::PdmUiOrdering::LayoutOptions::MAX_COLUMN_SPAN, 1 } );
// uiOrdering.add( &m_filterQuantitySelectButton, {false, 1, 0} );
}
if ( m_filterTarget() != ENSEMBLE_CASE )
{
uiOrdering.add( &m_consideredTimestepsType, {true, caf::PdmUiOrdering::LayoutOptions::MAX_COLUMN_SPAN, 1} );
uiOrdering.add( &m_consideredTimestepsType, { true, caf::PdmUiOrdering::LayoutOptions::MAX_COLUMN_SPAN, 1 } );
if ( m_consideredTimestepsType == SELECT_TIMESTEPS || m_consideredTimestepsType == SELECT_TIMESTEP_RANGE )
{
uiOrdering.add( &m_explicitlySelectedTimeSteps );
@ -369,16 +369,16 @@ void RimPlotDataFilterItem::defineUiOrdering( QString uiConfigName, caf::PdmUiOr
}
else
{
uiOrdering.add( &m_filterOperation, {true, 2, 1} );
uiOrdering.add( &m_filterOperation, { true, 2, 1 } );
if ( m_filterOperation() == RANGE )
{
uiOrdering.add( &m_max, {true, caf::PdmUiOrdering::LayoutOptions::MAX_COLUMN_SPAN, 1} );
uiOrdering.add( &m_min, {true, caf::PdmUiOrdering::LayoutOptions::MAX_COLUMN_SPAN, 1} );
uiOrdering.add( &m_max, { true, caf::PdmUiOrdering::LayoutOptions::MAX_COLUMN_SPAN, 1 } );
uiOrdering.add( &m_min, { true, caf::PdmUiOrdering::LayoutOptions::MAX_COLUMN_SPAN, 1 } );
}
else if ( m_filterOperation == TOP_N || m_filterOperation == BOTTOM_N )
{
uiOrdering.add( &m_topBottomN, {false} );
uiOrdering.add( &m_topBottomN, { false } );
}
}

4
ApplicationCode/ProjectDataModel/Annotations/RimUserDefinedPolylinesAnnotation.cpp
View File

@ -80,7 +80,7 @@ cvf::ref<RigPolyLinesData> RimUserDefinedPolylinesAnnotation::polyLinesData()
{
line.push_back( target->targetPointXYZ() );
}
pld->setPolyLines( {line} );
pld->setPolyLines( { line } );
return pld;
}
@ -170,7 +170,7 @@ std::pair<RimPolylineTarget*, RimPolylineTarget*>
if ( wt->isEnabled() && !foundTarget ) before = wt;
}
return {before, after};
return { before, after };
}
//--------------------------------------------------------------------------------------------------

12
ApplicationCode/ProjectDataModel/Completions/RimFractureModel.cpp
View File

@ -778,8 +778,8 @@ void RimFractureModel::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderin
m_azimuthAngle.uiCapability()->setUiHidden( m_fractureOrientation() != RimFractureModel::FractureOrientation::AZIMUTH );
uiOrdering.add( nameField(), caf::PdmUiOrdering::LayoutOptions( true, 3, 1 ) );
uiOrdering.add( &m_fractureModelTemplate, {true, 2, 1} );
uiOrdering.add( &m_editFractureModelTemplate, {false, 1, 0} );
uiOrdering.add( &m_fractureModelTemplate, { true, 2, 1 } );
uiOrdering.add( &m_editFractureModelTemplate, { false, 1, 0 } );
uiOrdering.add( &m_MD );
uiOrdering.add( &m_extractionType );
@ -810,7 +810,7 @@ void RimFractureModel::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderin
asymmetricGroup->add( &m_barrierFaultName );
asymmetricGroup->add( &m_showOnlyBarrierFault, caf::PdmUiOrdering::LayoutOptions( true, 2, 1 ) );
asymmetricGroup->add( &m_showAllFaults, {false, 1, 0} );
asymmetricGroup->add( &m_showAllFaults, { false, 1, 0 } );
asymmetricGroup->add( &m_wellPenetrationLayer );
}
@ -1116,9 +1116,9 @@ double RimFractureModel::getDefaultValueForProperty( RiaDefines::CurveProperty c
//--------------------------------------------------------------------------------------------------
bool RimFractureModel::hasDefaultValueForProperty( RiaDefines::CurveProperty curveProperty ) const
{
auto withDefaults = {RiaDefines::CurveProperty::RELATIVE_PERMEABILITY_FACTOR,
RiaDefines::CurveProperty::PORO_ELASTIC_CONSTANT,
RiaDefines::CurveProperty::THERMAL_EXPANSION_COEFFICIENT};
auto withDefaults = { RiaDefines::CurveProperty::RELATIVE_PERMEABILITY_FACTOR,
RiaDefines::CurveProperty::PORO_ELASTIC_CONSTANT,
RiaDefines::CurveProperty::THERMAL_EXPANSION_COEFFICIENT };
return std::find( withDefaults.begin(), withDefaults.end(), curveProperty ) != withDefaults.end();
}

6
ApplicationCode/ProjectDataModel/Completions/RimValveTemplate.cpp
View File

@ -179,9 +179,9 @@ QList<caf::PdmOptionItemInfo> RimValveTemplate::calculateValueOptions( const caf
if ( fieldNeedingOptions == &m_type )
{
std::set<RiaDefines::WellPathComponentType> supportedTypes = {RiaDefines::WellPathComponentType::ICD,
RiaDefines::WellPathComponentType::AICD,
RiaDefines::WellPathComponentType::ICV};
std::set<RiaDefines::WellPathComponentType> supportedTypes = { RiaDefines::WellPathComponentType::ICD,
RiaDefines::WellPathComponentType::AICD,
RiaDefines::WellPathComponentType::ICV };
for ( RiaDefines::WellPathComponentType type : supportedTypes )
{
options.push_back( caf::PdmOptionItemInfo( CompletionTypeEnum::uiText( type ), type ) );

4
ApplicationCode/ProjectDataModel/Completions/RimWellPathFracture.cpp
View File

@ -235,8 +235,8 @@ void RimWellPathFracture::defineUiOrdering( QString uiConfigName, caf::PdmUiOrde
if ( m_fractureTemplate() )
{
uiOrdering.add( nameField(), caf::PdmUiOrdering::LayoutOptions( true, 3, 1 ) );
uiOrdering.add( &m_fractureTemplate, {true, 2, 1} );
uiOrdering.add( &m_editFractureTemplate, {false, 1, 0} );
uiOrdering.add( &m_fractureTemplate, { true, 2, 1 } );
uiOrdering.add( &m_editFractureTemplate, { false, 1, 0 } );
}
else
{

4
ApplicationCode/ProjectDataModel/Completions/RimWellPathValve.cpp
View File

@ -499,7 +499,7 @@ void RimWellPathValve::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderin
{
uiOrdering.skipRemainingFields( true );
uiOrdering.add( &m_valveTemplate, {true, 2, 1} );
uiOrdering.add( &m_valveTemplate, { true, 2, 1 } );
{
if ( m_valveTemplate() != nullptr )
@ -527,7 +527,7 @@ void RimWellPathValve::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderin
m_measuredDepth.uiCapability()->setUiName( "Measured Depth [ft]" );
}
}
uiOrdering.add( &m_measuredDepth, {true, 3, 1} );
uiOrdering.add( &m_measuredDepth, { true, 3, 1 } );
}
}

2
ApplicationCode/ProjectDataModel/CorrelationPlots/RimCorrelationMatrixPlot.cpp
View File

@ -296,7 +296,7 @@ void RimCorrelationMatrixPlot::defineUiOrdering( QString uiConfigName, caf::PdmU
m_selectedVarsUiField = selectedVarsText();
curveDataGroup->add( &m_selectedVarsUiField );
curveDataGroup->add( &m_pushButtonSelectSummaryAddress, {false, 1, 0} );
curveDataGroup->add( &m_pushButtonSelectSummaryAddress, { false, 1, 0 } );
curveDataGroup->add( &m_timeStepFilter );
curveDataGroup->add( &m_timeStep );

2
ApplicationCode/ProjectDataModel/CorrelationPlots/RimCorrelationPlot.cpp
View File

@ -133,7 +133,7 @@ void RimCorrelationPlot::defineUiOrdering( QString uiConfigName, caf::PdmUiOrder
caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup( "Summary Vector" );
curveDataGroup->add( &m_selectedVarsUiField );
curveDataGroup->add( &m_pushButtonSelectSummaryAddress, {false, 1, 0} );
curveDataGroup->add( &m_pushButtonSelectSummaryAddress, { false, 1, 0 } );
curveDataGroup->add( &m_timeStepFilter );
curveDataGroup->add( &m_timeStep );

12
ApplicationCode/ProjectDataModel/CorrelationPlots/RimCorrelationPlotCollection.cpp
View File

@ -56,7 +56,7 @@ RimCorrelationPlot* RimCorrelationPlotCollection::createCorrelationPlot( bool de
RimCorrelationPlot* plot = new RimCorrelationPlot();
plot->setAsPlotMdiWindow();
if ( defaultToFirstEnsembleFopt ) applyFirstEnsembleFieldAddressesToPlot( plot, {"FOPT"} );
if ( defaultToFirstEnsembleFopt ) applyFirstEnsembleFieldAddressesToPlot( plot, { "FOPT" } );
plot->selectAllParameters();
addPlot( plot );
@ -74,7 +74,7 @@ RimCorrelationPlot* RimCorrelationPlotCollection::createCorrelationPlot( RimSumm
RimCorrelationPlot* plot = new RimCorrelationPlot();
plot->setAsPlotMdiWindow();
applyEnsembleFieldAndTimeStepToPlot( plot, ensemble, {quantityName}, timeStep );
applyEnsembleFieldAndTimeStepToPlot( plot, ensemble, { quantityName }, timeStep );
plot->selectAllParameters();
addPlot( plot );
@ -89,7 +89,7 @@ RimCorrelationMatrixPlot* RimCorrelationPlotCollection::createCorrelationMatrixP
{
RimCorrelationMatrixPlot* plot = new RimCorrelationMatrixPlot();
plot->setAsPlotMdiWindow();
if ( defaultToFirstEnsembleField ) applyFirstEnsembleFieldAddressesToPlot( plot, {"FOPT", "FWPT", "FGPT"} );
if ( defaultToFirstEnsembleField ) applyFirstEnsembleFieldAddressesToPlot( plot, { "FOPT", "FWPT", "FGPT" } );
plot->selectAllParameters();
addPlot( plot );
@ -121,7 +121,7 @@ RimParameterResultCrossPlot* RimCorrelationPlotCollection::createParameterResult
{
RimParameterResultCrossPlot* plot = new RimParameterResultCrossPlot;
plot->setAsPlotMdiWindow();
if ( defaultToFirstEnsembleFopt ) applyFirstEnsembleFieldAddressesToPlot( plot, {"FOPT"} );
if ( defaultToFirstEnsembleFopt ) applyFirstEnsembleFieldAddressesToPlot( plot, { "FOPT" } );
addPlot( plot );
return plot;
@ -137,7 +137,7 @@ RimParameterResultCrossPlot* RimCorrelationPlotCollection::createParameterResult
{
RimParameterResultCrossPlot* plot = new RimParameterResultCrossPlot;
plot->setAsPlotMdiWindow();
applyEnsembleFieldAndTimeStepToPlot( plot, ensemble, {quantityName}, timeStep );
applyEnsembleFieldAndTimeStepToPlot( plot, ensemble, { quantityName }, timeStep );
plot->setEnsembleParameter( paramName );
addPlot( plot );
@ -153,7 +153,7 @@ RimCorrelationReportPlot*
RimCorrelationReportPlot* report = new RimCorrelationReportPlot;
report->setAsPlotMdiWindow();
if ( defaultToFirstEnsembleField )
applyFirstEnsembleFieldAddressesToReport( report, {"FOPT", "FWPT", "FGPT"}, "FOPT" );
applyFirstEnsembleFieldAddressesToReport( report, { "FOPT", "FWPT", "FGPT" }, "FOPT" );
report->matrixPlot()->selectAllParameters();
report->correlationPlot()->selectAllParameters();
m_correlationReports.push_back( report );

4
ApplicationCode/ProjectDataModel/CorrelationPlots/RimCorrelationReportPlot.cpp
View File

@ -402,9 +402,9 @@ void RimCorrelationReportPlot::onDataSelection( const caf::SignalEmitter*
auto paramName = parameterAndCurveDef.first;
auto curveDef = parameterAndCurveDef.second;
m_correlationPlot->setCurveDefinitions( {curveDef} );
m_correlationPlot->setCurveDefinitions( { curveDef } );
m_correlationPlot->loadDataAndUpdate();
m_parameterResultCrossPlot->setCurveDefinitions( {curveDef} );
m_parameterResultCrossPlot->setCurveDefinitions( { curveDef } );
m_parameterResultCrossPlot->setEnsembleParameter( paramName );
m_parameterResultCrossPlot->loadDataAndUpdate();
if ( m_viewer )

2
ApplicationCode/ProjectDataModel/CorrelationPlots/RimParameterResultCrossPlot.cpp
View File

@ -118,7 +118,7 @@ void RimParameterResultCrossPlot::defineUiOrdering( QString uiConfigName, caf::P
caf::PdmUiGroup* curveDataGroup = uiOrdering.addNewGroup( "Summary Vector" );
curveDataGroup->add( &m_selectedVarsUiField );
curveDataGroup->add( &m_pushButtonSelectSummaryAddress, {false, 1, 0} );
curveDataGroup->add( &m_pushButtonSelectSummaryAddress, { false, 1, 0 } );
curveDataGroup->add( &m_timeStepFilter );
curveDataGroup->add( &m_timeStep );

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

@ -822,7 +822,7 @@ QString RimFlowCharacteristicsPlot::curveDataAsText() const
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();
for ( const auto& timeIndex : m_currentlyPlottedTimeSteps )

6
ApplicationCode/ProjectDataModel/Flow/RimWellAllocationPlot.cpp
View File

@ -125,9 +125,9 @@ RimWellAllocationPlot::RimWellAllocationPlot()
this->setAsPlotMdiWindow();
m_accumulatedWellFlowPlot->setAvailableDepthUnits( {} );
m_accumulatedWellFlowPlot->setAvailableDepthTypes( {RiaDefines::DepthTypeEnum::CONNECTION_NUMBER,
RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH,
RiaDefines::DepthTypeEnum::PSEUDO_LENGTH} );
m_accumulatedWellFlowPlot->setAvailableDepthTypes( { RiaDefines::DepthTypeEnum::CONNECTION_NUMBER,
RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH,
RiaDefines::DepthTypeEnum::PSEUDO_LENGTH } );
m_accumulatedWellFlowPlot->setCommonDataSourceEnabled( false );

10
ApplicationCode/ProjectDataModel/Flow/RimWellPlotTools.cpp
View File

@ -48,12 +48,12 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::set<QString> RimWellPlotTools::PRESSURE_DATA_NAMES = {"PRESSURE", "PRES_FORM"};
const std::set<QString> RimWellPlotTools::PRESSURE_DATA_NAMES = { "PRESSURE", "PRES_FORM" };
const std::set<QString> RimWellPlotTools::OIL_CHANNEL_NAMES = {"QOZT", "QOIL", "^.*\\D_QOIL"};
const std::set<QString> RimWellPlotTools::GAS_CHANNEL_NAMES = {"QGZT", "QGAS", "^.*\\D_QGAS"};
const std::set<QString> RimWellPlotTools::WATER_CHANNEL_NAMES = {"QWZT", "QWAT", "^.*\\D_QWAT"};
const std::set<QString> RimWellPlotTools::TOTAL_CHANNEL_NAMES = {"QTZT", "QTOT", "^.*\\D_QTOT"};
const std::set<QString> RimWellPlotTools::OIL_CHANNEL_NAMES = { "QOZT", "QOIL", "^.*\\D_QOIL" };
const std::set<QString> RimWellPlotTools::GAS_CHANNEL_NAMES = { "QGZT", "QGAS", "^.*\\D_QGAS" };
const std::set<QString> RimWellPlotTools::WATER_CHANNEL_NAMES = { "QWZT", "QWAT", "^.*\\D_QWAT" };
const std::set<QString> RimWellPlotTools::TOTAL_CHANNEL_NAMES = { "QTZT", "QTOT", "^.*\\D_QTOT" };
std::set<QString> RimWellPlotTools::FLOW_DATA_NAMES = {};

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

@ -125,7 +125,7 @@ RimWellPltPlot::RimWellPltPlot()
CAF_PDM_InitFieldNoDefault( &m_phases, "Phases", "Phases", "", "", "" );
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_nameConfig->setCustomName( "PLT Plot" );
@ -135,7 +135,7 @@ RimWellPltPlot::RimWellPltPlot()
m_isOnLoad = true;
m_plotLegendsHorizontal = false;
setAvailableDepthTypes( {RiaDefines::DepthTypeEnum::MEASURED_DEPTH} );
setAvailableDepthTypes( { RiaDefines::DepthTypeEnum::MEASURED_DEPTH } );
setPlotTitleVisible( true );
}

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

@ -124,7 +124,7 @@ RimWellRftPlot::RimWellRftPlot()
// TODO: may want to support TRUE_VERTICAL_DEPTH_RKB in the future
// It was developed for regular well log plots and requires some more work for RFT plots.
setAvailableDepthTypes( {RiaDefines::DepthTypeEnum::MEASURED_DEPTH, RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH} );
setAvailableDepthTypes( { RiaDefines::DepthTypeEnum::MEASURED_DEPTH, RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH } );
m_nameConfig->setCustomName( "RFT Plot" );
m_plotLegendsHorizontal = false;
@ -381,7 +381,7 @@ void RimWellRftPlot::updateEditorsFromCurves()
selectedSources.insert( curveDef.address() );
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 );
selectedTimeSteps.insert( curveDef.timeStep() );
}
@ -1276,12 +1276,12 @@ void RimWellRftPlot::defineCurveColorsAndSymbols( const std::set<RiaRftPltCurveD
std::vector<cvf::Color3f> colorTable;
RiaColorTables::summaryCurveDefaultPaletteColors().color3fArray().toStdVector( &colorTable );
std::vector<RiuQwtSymbol::PointSymbolEnum> symbolTable = {RiuQwtSymbol::SYMBOL_ELLIPSE,
RiuQwtSymbol::SYMBOL_RECT,
RiuQwtSymbol::SYMBOL_DIAMOND,
RiuQwtSymbol::SYMBOL_CROSS,
RiuQwtSymbol::SYMBOL_XCROSS,
RiuQwtSymbol::SYMBOL_STAR1};
std::vector<RiuQwtSymbol::PointSymbolEnum> symbolTable = { RiuQwtSymbol::SYMBOL_ELLIPSE,
RiuQwtSymbol::SYMBOL_RECT,
RiuQwtSymbol::SYMBOL_DIAMOND,
RiuQwtSymbol::SYMBOL_CROSS,
RiuQwtSymbol::SYMBOL_XCROSS,
RiuQwtSymbol::SYMBOL_STAR1 };
// Add new curves
for ( const RiaRftPltCurveDefinition& curveDefToAdd : allCurveDefs )

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

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

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

@ -955,7 +955,10 @@ QList<caf::PdmOptionItemInfo>
}
else if ( fieldNeedingOptions == &m_grouping )
{
std::set<RigGridCrossPlotCurveGrouping> validOptions = {NO_GROUPING, GROUP_BY_TIME, GROUP_BY_FORMATION, GROUP_BY_RESULT};
std::set<RigGridCrossPlotCurveGrouping> validOptions = { NO_GROUPING,
GROUP_BY_TIME,
GROUP_BY_FORMATION,
GROUP_BY_RESULT };
if ( !hasMultipleTimeSteps() )
{
validOptions.erase( GROUP_BY_TIME );
@ -1116,16 +1119,16 @@ void RimGridCrossPlotDataSet::exportFormattedData( RifTextDataTableFormatter& fo
if ( m_grouping != NO_GROUPING )
{
std::vector<RifTextDataTableColumn> header = {RifTextDataTableColumn( xTitle ),
RifTextDataTableColumn( yTitle ),
RifTextDataTableColumn( "Group Index" ),
RifTextDataTableColumn( "Group Description" )};
std::vector<RifTextDataTableColumn> header = { RifTextDataTableColumn( xTitle ),
RifTextDataTableColumn( yTitle ),
RifTextDataTableColumn( "Group Index" ),
RifTextDataTableColumn( "Group Description" ) };
formatter.header( header );
}
else
{
std::vector<RifTextDataTableColumn> header = {RifTextDataTableColumn( xTitle ), RifTextDataTableColumn( yTitle )};
std::vector<RifTextDataTableColumn> header = { RifTextDataTableColumn( xTitle ), RifTextDataTableColumn( yTitle ) };
formatter.header( header );
}

72
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@ -1286,41 +1286,41 @@ QString Rim3dOverlayInfoConfig::timeStepText( RimGeoMechView* geoMechView )
std::vector<RigEclipseResultAddress> sourcesForMultiPropertyResults( const QString& resultName )
{
static const std::map<QString, std::vector<RigEclipseResultAddress>> resultsWithMultiPropertySource =
{{RiaDefines::combinedTransmissibilityResultName(),
{RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANX" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANY" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANZ" )}},
{RiaDefines::combinedMultResultName(),
{RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX-" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY-" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ-" )}},
{RiaDefines::combinedRiTranResultName(),
{RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranZResultName() )}},
{RiaDefines::combinedRiMultResultName(),
{RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultZResultName() )}},
{RiaDefines::combinedRiAreaNormTranResultName(),
{RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranZResultName() )}},
{RiaDefines::combinedWaterFluxResultName(),
{RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATI+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATJ+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATK+" )}},
{RiaDefines::combinedOilFluxResultName(),
{RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILI+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILJ+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILK+" )}},
{RiaDefines::combinedGasFluxResultName(),
{RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASI+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASJ+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASK+" )}}};
{ { RiaDefines::combinedTransmissibilityResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANX" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANY" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "TRANZ" ) } },
{ RiaDefines::combinedMultResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTX-" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTY-" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, "MULTZ-" ) } },
{ RiaDefines::combinedRiTranResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riTranZResultName() ) } },
{ RiaDefines::combinedRiMultResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riMultZResultName() ) } },
{ RiaDefines::combinedRiAreaNormTranResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranXResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranYResultName() ),
RigEclipseResultAddress( RiaDefines::ResultCatType::STATIC_NATIVE, RiaDefines::riAreaNormTranZResultName() ) } },
{ RiaDefines::combinedWaterFluxResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATI+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATJ+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRWATK+" ) } },
{ RiaDefines::combinedOilFluxResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILI+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILJ+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLROILK+" ) } },
{ RiaDefines::combinedGasFluxResultName(),
{ RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASI+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASJ+" ),
RigEclipseResultAddress( RiaDefines::ResultCatType::DYNAMIC_NATIVE, "FLRGASK+" ) } } };
auto resNameResultAddrsPairIt = resultsWithMultiPropertySource.find( resultName );
@ -1333,7 +1333,7 @@ std::vector<RigEclipseResultAddress> sourcesForMultiPropertyResults( const QStri
std::vector<RigEclipseResultAddress> resultAddrs;
QString baseName = resultName.left( resultName.size() - 3 );
QStringList endings = {"I", "J", "K"};
QStringList endings = { "I", "J", "K" };
for ( QString ending : endings )
{

4
ApplicationCode/ProjectDataModel/RimContourMapProjection.cpp
View File

@ -984,11 +984,11 @@ void RimContourMapProjection::generateTrianglesWithVertexValues()
std::vector<cvf::Vec3d> clippedTriangle;
if ( v == clippedPolygon.size() - 1 )
{
clippedTriangle = {clippedPolygon[v], clippedPolygon[0], baryCenter};
clippedTriangle = { clippedPolygon[v], clippedPolygon[0], baryCenter };
}
else
{
clippedTriangle = {clippedPolygon[v], clippedPolygon[v + 1], baryCenter};
clippedTriangle = { clippedPolygon[v], clippedPolygon[v + 1], baryCenter };
}
polygonTriangles.push_back( clippedTriangle );
}

8
ApplicationCode/ProjectDataModel/RimDepthTrackPlot.cpp
View File

@ -125,10 +125,10 @@ RimDepthTrackPlot::RimDepthTrackPlot()
auto reorderability = caf::PdmFieldReorderCapability::addToField( &m_plots );
reorderability->orderChanged.connect( this, &RimDepthTrackPlot::onPlotsReordered );
m_availableDepthUnits = {RiaDefines::DepthUnitType::UNIT_METER, RiaDefines::DepthUnitType::UNIT_FEET};
m_availableDepthTypes = {RiaDefines::DepthTypeEnum::MEASURED_DEPTH,
RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH,
RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH_RKB};
m_availableDepthUnits = { RiaDefines::DepthUnitType::UNIT_METER, RiaDefines::DepthUnitType::UNIT_FEET };
m_availableDepthTypes = { RiaDefines::DepthTypeEnum::MEASURED_DEPTH,
RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH,
RiaDefines::DepthTypeEnum::TRUE_VERTICAL_DEPTH_RKB };
m_minAvailableDepth = HUGE_VAL;
m_maxAvailableDepth = -HUGE_VAL;

2
ApplicationCode/ProjectDataModel/RimEclipseCellColors.cpp
View File

@ -154,7 +154,7 @@ void RimEclipseCellColors::changeLegendConfig( QString resultVarNameOfNewLegend
bool useLog = false;
{
QStringList subStringsToMatch{"TRAN", "MULT", "PERM"};
QStringList subStringsToMatch{ "TRAN", "MULT", "PERM" };
for ( const auto& s : subStringsToMatch )
{

8
ApplicationCode/ProjectDataModel/RimEclipsePropertyFilter.cpp
View File

@ -412,10 +412,10 @@ void RimEclipsePropertyFilter::computeResultValueRange()
else if ( m_resultDefinition->resultVariable() == RiaDefines::completionTypeResultName() )
{
std::vector<RiaDefines::WellPathComponentType> componentTypes =
{RiaDefines::WellPathComponentType::WELL_PATH,
RiaDefines::WellPathComponentType::PERFORATION_INTERVAL,
RiaDefines::WellPathComponentType::FISHBONES,
RiaDefines::WellPathComponentType::FRACTURE};
{ RiaDefines::WellPathComponentType::WELL_PATH,
RiaDefines::WellPathComponentType::PERFORATION_INTERVAL,
RiaDefines::WellPathComponentType::FISHBONES,
RiaDefines::WellPathComponentType::FRACTURE };
std::vector<std::pair<QString, int>> ctNamesAndValues;
for ( RiaDefines::WellPathComponentType type : componentTypes )
{

Some files were not shown because too many files have changed in this diff Show More