Fixes by clang-format

2026-09-03 20:53:13 -05:00 · 2020-11-06 06:18:34 -05:00
parent 318b4e3471
commit d11e109c7e
208 changed files with 67533 additions and 67439 deletions
@@ -350,7 +350,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 );
    }

@@ -1869,7 +1869,7 @@ bool RiaApplication::generateCode( const QString& fileName, gsl::not_null<QStrin

            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 )
@@ -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() };
 }

 //--------------------------------------------------------------------------------------------------
@@ -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 );
@@ -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++ )
    {
@@ -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 ) } };
 }

 //--------------------------------------------------------------------------------------------------
@@ -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" };

 //--------------------------------------------------------------------------------------------------
 ///
@@ -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] );
@@ -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;
@@ -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;

@@ -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 );

@@ -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 );
@@ -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;
@@ -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();
 }
@@ -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 );
@@ -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 ) );
@@ -94,10 +94,10 @@ RimStimPlanModelPlot* RicNewStimPlanModelPlotFeature::createPlot( RimStimPlanMod
        auto task = progInfo.task( "Creating parameters track", 15 );

        std::map<QString, std::vector<RiaDefines::CurveProperty>> plots;
-        plots["Porosity"]     = {RiaDefines::CurveProperty::POROSITY};
-        plots["Pressure"]     = {RiaDefines::CurveProperty::INITIAL_PRESSURE, RiaDefines::CurveProperty::PRESSURE};
-        plots["Permeability"] = {RiaDefines::CurveProperty::PERMEABILITY_X, RiaDefines::CurveProperty::PERMEABILITY_Z};
-        plots["Net-To-Gross"] = {RiaDefines::CurveProperty::NET_TO_GROSS};
+        plots["Porosity"]     = { RiaDefines::CurveProperty::POROSITY };
+        plots["Pressure"]     = { RiaDefines::CurveProperty::INITIAL_PRESSURE, RiaDefines::CurveProperty::PRESSURE };
+        plots["Permeability"] = { RiaDefines::CurveProperty::PERMEABILITY_X, RiaDefines::CurveProperty::PERMEABILITY_Z };
+        plots["Net-To-Gross"] = { RiaDefines::CurveProperty::NET_TO_GROSS };

        std::set<QString> logarithmicPlots;
        logarithmicPlots.insert( "Permeability" );
@@ -116,41 +116,46 @@ RimStimPlanModelPlot* RicNewStimPlanModelPlotFeature::createPlot( RimStimPlanMod
                               eclipseCase,
                               timeStep,
                               "Stress",
-                               {RiaDefines::CurveProperty::STRESS, RiaDefines::CurveProperty::INITIAL_STRESS} );
+                               { RiaDefines::CurveProperty::STRESS, RiaDefines::CurveProperty::INITIAL_STRESS } );
        createParametersTrack( plot,
                               stimPlanModel,
                               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 )
        {
            QString trackName = caf::AppEnum<RiaDefines::CurveProperty>::uiText( result );
-            createParametersTrack( plot, stimPlanModel, eclipseCase, timeStep, trackName, {result} );
+            createParametersTrack( plot, stimPlanModel, eclipseCase, timeStep, trackName, { result } );
        }
    }

    {
        auto task = progInfo.task( "Creating temperature track", 2 );
-        createParametersTrack( plot, stimPlanModel, eclipseCase, timeStep, "Temperature", {RiaDefines::CurveProperty::TEMPERATURE} );
+        createParametersTrack( plot,
+                               stimPlanModel,
+                               eclipseCase,
+                               timeStep,
+                               "Temperature",
+                               { RiaDefines::CurveProperty::TEMPERATURE } );
    }

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

-        RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions( completionExportSettings, {wellPath} );
+        RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions( completionExportSettings, { wellPath } );
    }
 }

@@ -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 );
            }
        }
@@ -625,8 +625,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 )
@@ -661,10 +661,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 );
        }
    }
@@ -685,7 +685,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() )
            {
@@ -834,9 +834,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;

@@ -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" );
    }
@@ -1270,7 +1272,7 @@ void RicWellPathExportCompletionDataFeatureImpl::appendCompletionData(
        {
            completionData->insert(
                std::pair<size_t, std::vector<RigCompletionData>>( completion.completionDataGridCell().globalCellIndex(),
-                                                                   std::vector<RigCompletionData>{completion} ) );
+                                                                   std::vector<RigCompletionData>{ completion } ) );
        }
    }
 }
@@ -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:" );
@@ -1033,7 +1032,7 @@ RicMswExportInfo
                    RicExportFractureCompletionsImpl::generateCompdatValues( caseToApply,
                                                                             wellPath->completions()->wellNameForExport(),
                                                                             wellPath->wellPathGeometry(),
-                                                                             {fracture},
+                                                                             { fracture },
                                                                             nullptr,
                                                                             nullptr );

@@ -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( '-' );
@@ -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 );
@@ -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,
@@ -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" };
 }

 //--------------------------------------------------------------------------------------------------
@@ -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 } } };
 }

 //--------------------------------------------------------------------------------------------------
@@ -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 );
@@ -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++ )
    {
@@ -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 };
        }
    }
 }
@@ -80,7 +80,7 @@ RimStimPlanModel* RicNewStimPlanModelFeature::addStimPlanModel( RimWellPath*
    RimModeledWellPath* thicknessDirectionWellPath = new RimModeledWellPath;
    stimPlanModel->setThicknessDirectionWellPath( thicknessDirectionWellPath );

-    std::vector<RimWellPath*> wellPaths = {thicknessDirectionWellPath};
+    std::vector<RimWellPath*> wellPaths = { thicknessDirectionWellPath };
    wellPathCollection->addWellPaths( wellPaths, false );

    if ( project )
@@ -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 };

 //--------------------------------------------------------------------------------------------------
 ///
@@ -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 )
@@ -95,7 +95,7 @@ void RicImportEnsembleFeature::onActionTriggered( bool isChecked )

    if ( ensemble )
    {
-        RicNewSummaryEnsembleCurveSetFeature::createPlotForCurveSetsAndUpdate( {ensemble} );
+        RicNewSummaryEnsembleCurveSetFeature::createPlotForCurveSetsAndUpdate( { ensemble } );
    }

    std::vector<RimCase*> allCases;
@@ -267,7 +267,7 @@ QStringList RicRecursiveFileSearchDialog::fileExtensions() const
    QString extFromFilter = extensionFromFileNameFilter();
    if ( !extFromFilter.isEmpty() )
    {
-        return QStringList( {extFromFilter} );
+        return QStringList( { extFromFilter } );
    }

    QStringList exts = m_fileExtensions;
@@ -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] );
@@ -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 )
    {
@@ -266,9 +266,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 )
@@ -315,12 +315,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;
@@ -381,9 +381,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 )
    {
@@ -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 ) );
@@ -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 );
        }

@@ -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 );
        }

@@ -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" };

 //--------------------------------------------------------------------------------------------------
 ///
@@ -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 );
    }
@@ -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 {};
 }
@@ -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 )
    {
@@ -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, "" ) } );
 }

 //--------------------------------------------------------------------------------------------------
@@ -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
@@ -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(
@@ -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 {};
 }
@@ -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 )
                {
@@ -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;
@@ -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;
@@ -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" );
@@ -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() ) );
    }
@@ -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 )
    {
@@ -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;

@@ -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 )
    {
@@ -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 =
@@ -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 =
@@ -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 ) };
 }

 //--------------------------------------------------------------------------------------------------
@@ -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 =
@@ -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;
 }
@@ -214,14 +214,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>(
@@ -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 )
    {
@@ -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 )
        {
@@ -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 } ) );
 }

 //--------------------------------------------------------------------------------------------------
@@ -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;
@@ -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 )
                    {
@@ -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 };
    }
 }

@@ -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 );
 }

@@ -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.
 }
@@ -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 );

@@ -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();
@@ -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;
@@ -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 )
@@ -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 } );
    }
 }

@@ -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

@@ -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 )
@@ -1700,7 +1700,7 @@ std::vector<RiaSummaryCurveDefinition> RimAnalysisPlot::curveDefinitions() const
 //--------------------------------------------------------------------------------------------------
 std::set<RimPlotAxisPropertiesInterface*> RimAnalysisPlot::allPlotAxes() const
 {
-    return {m_valueAxisProperties};
+    return { m_valueAxisProperties };
 }

 //--------------------------------------------------------------------------------------------------
@@ -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 );
@@ -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 } );
        }
    }

@@ -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 };
 }

 //--------------------------------------------------------------------------------------------------
@@ -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 ) );
@@ -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
    {
@@ -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 } );
        }
    }

@@ -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 );

@@ -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 );

@@ -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 );
@@ -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 )
@@ -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 );

@@ -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 )
@@ -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 );

@@ -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 = {};

@@ -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 );
 }

@@ -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 )
@@ -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 };
 }

 //--------------------------------------------------------------------------------------------------
@@ -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 );
    }

@@ -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 )
        {
@@ -974,11 +974,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 );
                            }
@@ -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;
@@ -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 )
                    {
@@ -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 )
                        {
@@ -2001,10 +2001,10 @@ void RimEclipseResultDefinition::updateRangesForExplicitLegends( RimRegularLegen
                        cellResultsData->uniqueCellScalarValues( this->eclipseResultAddress() );

                    std::vector<RiaDefines::WellPathComponentType> supportedCompletionTypes =
-                        {RiaDefines::WellPathComponentType::WELL_PATH,
-                         RiaDefines::WellPathComponentType::FISHBONES,
-                         RiaDefines::WellPathComponentType::PERFORATION_INTERVAL,
-                         RiaDefines::WellPathComponentType::FRACTURE};
+                        { RiaDefines::WellPathComponentType::WELL_PATH,
+                          RiaDefines::WellPathComponentType::FISHBONES,
+                          RiaDefines::WellPathComponentType::PERFORATION_INTERVAL,
+                          RiaDefines::WellPathComponentType::FRACTURE };

                    RiaColorTables::WellPathComponentColors colors = RiaColorTables::wellPathComponentColors();

--- a/Show More
+++ b/Show More