clang-format: Set column width to 140

* Set column width to 140
* Use c++20
* Remove redundant virtual

ApplicationLibCode/FileInterface/RifActiveCellsReader.cpp

@@ -52,9 +52,8 @@ std::vector<std::vector<int>> RifActiveCellsReader::activeCellsFromActnumKeyword
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<std::vector<int>> RifActiveCellsReader::activeCellsFromPorvKeyword( const ecl_file_type* ecl_file,
-                                                                                bool                 dualPorosity,
-                                                                                const int            cellCountMainGrid )
+std::vector<std::vector<int>>
+    RifActiveCellsReader::activeCellsFromPorvKeyword( const ecl_file_type* ecl_file, bool dualPorosity, const int cellCountMainGrid )
 {
     CAF_ASSERT( ecl_file );
 
@@ -125,8 +124,7 @@ std::vector<std::vector<int>> RifActiveCellsReader::activeCellsFromPorvKeyword(
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifActiveCellsReader::applyActiveCellsToAllGrids( ecl_grid_type*                       ecl_main_grid,
-                                                       const std::vector<std::vector<int>>& activeCellsForAllGrids )
+void RifActiveCellsReader::applyActiveCellsToAllGrids( ecl_grid_type* ecl_main_grid, const std::vector<std::vector<int>>& activeCellsForAllGrids )
 {
     CAF_ASSERT( ecl_main_grid );
 

ApplicationLibCode/FileInterface/RifActiveCellsReader.h

@@ -35,6 +35,5 @@ public:
     static std::vector<std::vector<int>>
         activeCellsFromPorvKeyword( const ecl_file_type* ecl_file, bool dualPorosity, const int cellCountMainGrid );
 
-    static void applyActiveCellsToAllGrids( ecl_grid_type*                       ecl_main_grid,
-                                            const std::vector<std::vector<int>>& activeCellsForAllGrids );
+    static void applyActiveCellsToAllGrids( ecl_grid_type* ecl_main_grid, const std::vector<std::vector<int>>& activeCellsForAllGrids );
 };

ApplicationLibCode/FileInterface/RifCaseRealizationParametersReader.cpp

@@ -218,8 +218,7 @@ void RifCaseRealizationRunspecificationReader::parse()
                     else
                     {
                         errors
-                            << QString( "RifCaseRealizationRunspecificationReader: Invalid number format in line %1" )
-                                   .arg( xml.lineNumber() );
+                            << QString( "RifCaseRealizationRunspecificationReader: Invalid number format in line %1" ).arg( xml.lineNumber() );
                     }
                 }
                 else

ApplicationLibCode/FileInterface/RifColorLegendData.cpp

@@ -88,8 +88,7 @@ cvf::ref<RigFormationNames> RifColorLegendData::readLyrFormationNameFile( const
             // extract last word which may contain formation color
             QString colorWord = RiaTextStringTools::splitSkipEmptyParts( numberString ).last();
 
-            if ( QColor::isValidColor( colorWord ) )
-                numberString.remove( colorWord ); // remove color if present as last word on line
+            if ( QColor::isValidColor( colorWord ) ) numberString.remove( colorWord ); // remove color if present as last word on line
 
             // extract words containing formation number(s)
             QStringList numberWords = RiaTextStringTools::splitSkipEmptyParts( numberString, QRegExp( "-" ) );
@@ -103,8 +102,7 @@ cvf::ref<RigFormationNames> RifColorLegendData::readLyrFormationNameFile( const
 
                 if ( !( isNumber2 && isNumber1 ) )
                 {
-                    if ( errorMessage )
-                        ( *errorMessage ) += "Format error on line: " + QString::number( lineNumber ) + "\n";
+                    if ( errorMessage ) ( *errorMessage ) += "Format error on line: " + QString::number( lineNumber ) + "\n";
                     continue;
                 }
 
@@ -131,8 +129,7 @@ cvf::ref<RigFormationNames> RifColorLegendData::readLyrFormationNameFile( const
 
                 if ( !isNumber1 )
                 {
-                    if ( errorMessage )
-                        ( *errorMessage ) += "Format error on line: " + QString::number( lineNumber ) + "\n";
+                    if ( errorMessage ) ( *errorMessage ) += "Format error on line: " + QString::number( lineNumber ) + "\n";
                     continue;
                 }
 
@@ -150,8 +147,7 @@ cvf::ref<RigFormationNames> RifColorLegendData::readLyrFormationNameFile( const
             }
             else
             {
-                if ( errorMessage )
-                    ( *errorMessage ) += "Format error on line: " + QString::number( lineNumber ) + "\n";
+                if ( errorMessage ) ( *errorMessage ) += "Format error on line: " + QString::number( lineNumber ) + "\n";
             }
         }
 

ApplicationLibCode/FileInterface/RifColumnBasedUserData.cpp

@@ -193,28 +193,24 @@ std::vector<time_t> RifColumnBasedUserData::createTimeSteps( const TableData& ta
     {
         const Column& ci = tableData.columnInfos()[columIndex];
 
-        if ( dateColumnIndex == tableData.columnInfos().size() &&
-             RifEclipseUserDataKeywordTools::isDate( ci.summaryAddress.vectorName() ) )
+        if ( dateColumnIndex == tableData.columnInfos().size() && RifEclipseUserDataKeywordTools::isDate( ci.summaryAddress.vectorName() ) )
         {
             dateColumnIndex = columIndex;
         }
 
-        if ( daysColumnIndex == tableData.columnInfos().size() &&
-             RifEclipseUserDataKeywordTools::isTime( ci.summaryAddress.vectorName() ) &&
+        if ( daysColumnIndex == tableData.columnInfos().size() && RifEclipseUserDataKeywordTools::isTime( ci.summaryAddress.vectorName() ) &&
              RifEclipseUserDataKeywordTools::isDays( ci.unitName ) )
         {
             daysColumnIndex = columIndex;
         }
 
-        if ( yearsColumnIndex == tableData.columnInfos().size() &&
-             RifEclipseUserDataKeywordTools::isYears( ci.summaryAddress.vectorName() ) &&
+        if ( yearsColumnIndex == tableData.columnInfos().size() && RifEclipseUserDataKeywordTools::isYears( ci.summaryAddress.vectorName() ) &&
              RifEclipseUserDataKeywordTools::isYears( ci.unitName ) )
         {
             yearsColumnIndex = columIndex;
         }
 
-        if ( yearXColumnIndex == tableData.columnInfos().size() &&
-             RifEclipseUserDataKeywordTools::isYearX( ci.summaryAddress.vectorName() ) &&
+        if ( yearXColumnIndex == tableData.columnInfos().size() && RifEclipseUserDataKeywordTools::isYearX( ci.summaryAddress.vectorName() ) &&
              RifEclipseUserDataKeywordTools::isYears( ci.unitName ) )
         {
             yearXColumnIndex = columIndex;

ApplicationLibCode/FileInterface/RifCsvUserDataParser.cpp

@@ -299,9 +299,7 @@ RifCsvUserDataParser::CsvLayout RifCsvUserDataParser::determineCsvLayout()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifCsvUserDataParser::parseColumnInfo( QTextStream*                 dataStream,
-                                            const AsciiDataParseOptions& parseOptions,
-                                            std::vector<Column>*         columnInfoList )
+bool RifCsvUserDataParser::parseColumnInfo( QTextStream* dataStream, const AsciiDataParseOptions& parseOptions, std::vector<Column>* columnInfoList )
 {
     bool headerFound = false;
 
@@ -325,8 +323,7 @@ bool RifCsvUserDataParser::parseColumnInfo( QTextStream*                 dataStr
         {
             QString candidateLine = dataStream->readLine();
 
-            QStringList candidateColumnHeaders =
-                RifFileParseTools::splitLineAndTrim( candidateLine, parseOptions.cellSeparator );
+            QStringList candidateColumnHeaders = RifFileParseTools::splitLineAndTrim( candidateLine, parseOptions.cellSeparator );
             for ( const auto& text : candidateColumnHeaders )
             {
                 if ( RiaStdStringTools::isNumber( text.toStdString(), parseOptions.locale.decimalPoint().toLatin1() ) )
@@ -369,9 +366,8 @@ bool RifCsvUserDataParser::parseColumnInfo( QTextStream*                 dataStr
             QString unit;
             if ( iCol < unitTexts.size() ) unit = unitTexts[iCol];
 
-            RifEclipseSummaryAddress addr =
-                RifEclipseSummaryAddress::fromEclipseTextAddressParseErrorTokens( colName.toStdString() );
-            Column col = Column::createColumnInfoFromCsvData( addr, unit.toStdString() );
+            RifEclipseSummaryAddress addr = RifEclipseSummaryAddress::fromEclipseTextAddressParseErrorTokens( colName.toStdString() );
+            Column                   col  = Column::createColumnInfoFromCsvData( addr, unit.toStdString() );
 
             columnInfoList->push_back( col );
         }
@@ -473,8 +469,7 @@ bool RifCsvUserDataParser::parseColumnBasedData( const AsciiDataParseOptions& pa
                             {
                                 if ( m_errorText )
                                     m_errorText->append(
-                                        QString( "CSV import: Failed to parse numeric value in column %1\n" )
-                                            .arg( QString::number( iCol + 1 ) ) );
+                                        QString( "CSV import: Failed to parse numeric value in column %1\n" ).arg( QString::number( iCol + 1 ) ) );
                                 throw 0;
                             }
 
@@ -610,8 +605,8 @@ bool RifCsvUserDataParser::parseLineBasedData()
                 if ( !dateTime.isValid() )
                 {
                     if ( m_errorText )
-                        m_errorText->append( QString( "CSV import: Failed to parse date time value in line %1" )
-                                                 .arg( QString::number( lineCount ) ) );
+                        m_errorText->append(
+                            QString( "CSV import: Failed to parse date time value in line %1" ).arg( QString::number( lineCount ) ) );
                     throw 0;
                 }
             }
@@ -619,14 +614,13 @@ bool RifCsvUserDataParser::parseLineBasedData()
             // VALUE
             {
                 bool   parseOk = true;
-                double value =
-                    QLocale::c().toDouble( dataItems[colIndexes[(size_t)CsvLineBasedColumnType::VALUE]], &parseOk );
+                double value   = QLocale::c().toDouble( dataItems[colIndexes[(size_t)CsvLineBasedColumnType::VALUE]], &parseOk );
 
                 if ( !parseOk )
                 {
                     if ( m_errorText )
-                        m_errorText->append( QString( "CSV import: Failed to parse numeric value in line %1\n" )
-                                                 .arg( QString::number( lineCount ) ) );
+                        m_errorText->append(
+                            QString( "CSV import: Failed to parse numeric value in line %1\n" ).arg( QString::number( lineCount ) ) );
                     throw 0;
                 }
 
@@ -638,8 +632,7 @@ bool RifCsvUserDataParser::parseLineBasedData()
             if ( expectErrorValue )
             {
                 bool   parseOk = true;
-                double value = QLocale::c().toDouble( dataItems[colIndexes[(size_t)CsvLineBasedColumnType::ERROR_VALUE]],
-                                                      &parseOk );
+                double value   = QLocale::c().toDouble( dataItems[colIndexes[(size_t)CsvLineBasedColumnType::ERROR_VALUE]], &parseOk );
 
                 if ( !parseOk ) value = DOUBLE_INF;
 
@@ -657,9 +650,7 @@ bool RifCsvUserDataParser::parseLineBasedData()
             auto samples = item.second;
 
             // Sort samples by time
-            std::sort( samples.begin(), samples.end(), []( const Sample& s1, const Sample& s2 ) {
-                return s1.first < s2.first;
-            } );
+            std::sort( samples.begin(), samples.end(), []( const Sample& s1, const Sample& s2 ) { return s1.first < s2.first; } );
 
             // Copy
             Column c   = Column::createColumnInfoFromCsvData( item.first, "" );

ApplicationLibCode/FileInterface/RifCsvUserDataParser.h

@@ -74,11 +74,9 @@ protected:
 private:
     std::vector<int> parseLineBasedHeader( QStringList headerCols );
 
-    bool             parseColumnInfo( QTextStream*                 dataStream,
-                                      const AsciiDataParseOptions& parseOptions,
-                                      std::vector<Column>*         columnInfoList );
-    bool             parseColumnBasedData( const AsciiDataParseOptions& parseOptions );
-    bool             parseLineBasedData();
+    bool parseColumnInfo( QTextStream* dataStream, const AsciiDataParseOptions& parseOptions, std::vector<Column>* columnInfoList );
+    bool parseColumnBasedData( const AsciiDataParseOptions& parseOptions );
+    bool parseLineBasedData();
     static QDateTime tryParseDateTime( const std::string& colData, const QString& format );
 
 private:

ApplicationLibCode/FileInterface/RifDataSourceForRftPlt.cpp

@@ -47,9 +47,7 @@ void caf::AppEnum<RifDataSourceForRftPlt::SourceType>::setUp()
     addItem( RifDataSourceForRftPlt::SourceType::SUMMARY_RFT, "SUMMARY_RFT", "Summary Data" );
     addItem( RifDataSourceForRftPlt::SourceType::ENSEMBLE_RFT, "ENSEMBLE", "Ensembles with RFT Data" );
     addItem( RifDataSourceForRftPlt::SourceType::OBSERVED_FMU_RFT, "OBSERVED_FMU", "Observed FMU Data" );
-    addItem( RifDataSourceForRftPlt::SourceType::OBSERVED_PRESSURE_DEPTH,
-             "OBSERVED_PRESSURE_DEPTH",
-             "Observed Pressure/Depth Data" );
+    addItem( RifDataSourceForRftPlt::SourceType::OBSERVED_PRESSURE_DEPTH, "OBSERVED_PRESSURE_DEPTH", "Observed Pressure/Depth Data" );
     setDefault( RifDataSourceForRftPlt::SourceType::NONE );
 }
 } // namespace caf
@@ -255,9 +253,9 @@ QString RifDataSourceForRftPlt::sourceTypeUiText( SourceType sourceType )
 //--------------------------------------------------------------------------------------------------
 bool operator==( const RifDataSourceForRftPlt& addr1, const RifDataSourceForRftPlt& addr2 )
 {
-    return addr1.sourceType() == addr2.sourceType() && addr1.eclCase() == addr2.eclCase() &&
-           addr1.wellLogFile() == addr2.wellLogFile() && addr1.summaryCase() == addr2.summaryCase() &&
-           addr1.ensemble() == addr2.ensemble() && addr1.observedFmuRftData() == addr2.observedFmuRftData();
+    return addr1.sourceType() == addr2.sourceType() && addr1.eclCase() == addr2.eclCase() && addr1.wellLogFile() == addr2.wellLogFile() &&
+           addr1.summaryCase() == addr2.summaryCase() && addr1.ensemble() == addr2.ensemble() &&
+           addr1.observedFmuRftData() == addr2.observedFmuRftData();
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifDerivedEnsembleReader.h

@@ -34,9 +34,9 @@ public:
                               RifSummaryReaderInterface* sourceSummaryReader1,
                               RifSummaryReaderInterface* sourceSummaryReader2 );
 
-    std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool        values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
-    std::string unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
+    std::vector<time_t>           timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
+    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::string                   unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem unitSystem() const override;
 
 private:

ApplicationLibCode/FileInterface/RifEclEclipseSummary.h

@@ -50,8 +50,8 @@ public:
 
     std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
 
-    bool        values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
-    std::string unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
+    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::string                   unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem unitSystem() const override;
 
 private:

ApplicationLibCode/FileInterface/RifEclipseInputFileTools.cpp

@@ -78,10 +78,7 @@ RifEclipseInputFileTools::~RifEclipseInputFileTools()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifEclipseInputFileTools::openGridFile( const QString&      fileName,
-                                             RigEclipseCaseData* eclipseCase,
-                                             bool                readFaultData,
-                                             QString*            errorMessages )
+bool RifEclipseInputFileTools::openGridFile( const QString& fileName, RigEclipseCaseData* eclipseCase, bool readFaultData, QString* errorMessages )
 {
     std::string filename = fileName.toStdString();
 
@@ -316,10 +313,7 @@ bool RifEclipseInputFileTools::exportGrid( const QString&         fileName,
                     }
                 }
 
-                auto refinedCoords = RiaCellDividingTools::createHexCornerCoords( cellCorners,
-                                                                                  refinement.x(),
-                                                                                  refinement.y(),
-                                                                                  refinement.z() );
+                auto refinedCoords = RiaCellDividingTools::createHexCornerCoords( cellCorners, refinement.x(), refinement.y(), refinement.z() );
 
                 size_t subI     = i % refinement.x();
                 size_t subJ     = j % refinement.y();
@@ -347,15 +341,8 @@ bool RifEclipseInputFileTools::exportGrid( const QString&         fileName,
     // The coordinates have been transformed to the map axes coordinate system already.
     // However, send the map axes data in to libecl so that the coordinate system description is saved.
     bool           applyMapaxes = false;
-    ecl_grid_type* mainEclGrid  = ecl_grid_alloc_GRID_data( (int)ecl_coords.size(),
-                                                           ecl_nx,
-                                                           ecl_ny,
-                                                           ecl_nz,
-                                                           5,
-                                                           &ecl_coords[0],
-                                                           &ecl_corners[0],
-                                                           applyMapaxes,
-                                                           mapAxes.data() );
+    ecl_grid_type* mainEclGrid =
+        ecl_grid_alloc_GRID_data( (int)ecl_coords.size(), ecl_nx, ecl_ny, ecl_nz, 5, &ecl_coords[0], &ecl_corners[0], applyMapaxes, mapAxes.data() );
     progress.setProgress( mainGrid->cellCount() );
 
     for ( float* floatArray : ecl_corners )
@@ -474,10 +461,7 @@ bool RifEclipseInputFileTools::exportKeywords( const QString&              resul
 
         // Multiple keywords can be exported to same file, so write ECHO keywords outside the loop
         bool writeEchoKeywordsInExporterObject = false;
-        RicEclipseCellResultToFileImpl::writeDataToTextFile( &exportFile,
-                                                             writeEchoKeywordsInExporterObject,
-                                                             keyword,
-                                                             filteredResults );
+        RicEclipseCellResultToFileImpl::writeDataToTextFile( &exportFile, writeEchoKeywordsInExporterObject, keyword, filteredResults );
 
         progress.incrementProgress();
     }
@@ -592,10 +576,8 @@ void RifEclipseInputFileTools::saveFault( QTextStream&
                 {
                     for ( size_t refineJ = 0; refineJ < refinement.y(); ++refineJ )
                     {
-                        faultCellAndFaces.push_back( std::make_tuple( shifted_i,
-                                                                      shifted_j + refineJ,
-                                                                      shifted_k + refineK,
-                                                                      faultCellAndFace.m_nativeFace ) );
+                        faultCellAndFaces.push_back(
+                            std::make_tuple( shifted_i, shifted_j + refineJ, shifted_k + refineK, faultCellAndFace.m_nativeFace ) );
                     }
                 }
             }
@@ -610,10 +592,8 @@ void RifEclipseInputFileTools::saveFault( QTextStream&
                 {
                     for ( size_t refineI = 0; refineI < refinement.x(); ++refineI )
                     {
-                        faultCellAndFaces.push_back( std::make_tuple( shifted_i + refineI,
-                                                                      shifted_j,
-                                                                      shifted_k + refineK,
-                                                                      faultCellAndFace.m_nativeFace ) );
+                        faultCellAndFaces.push_back(
+                            std::make_tuple( shifted_i + refineI, shifted_j, shifted_k + refineK, faultCellAndFace.m_nativeFace ) );
                     }
                 }
             }
@@ -628,10 +608,8 @@ void RifEclipseInputFileTools::saveFault( QTextStream&
                 {
                     for ( size_t refineI = 0; refineI < refinement.x(); ++refineI )
                     {
-                        faultCellAndFaces.push_back( std::make_tuple( shifted_i + refineI,
-                                                                      shifted_j + refineJ,
-                                                                      shifted_k,
-                                                                      faultCellAndFace.m_nativeFace ) );
+                        faultCellAndFaces.push_back(
+                            std::make_tuple( shifted_i + refineI, shifted_j + refineJ, shifted_k, faultCellAndFace.m_nativeFace ) );
                     }
                 }
             }
@@ -699,8 +677,7 @@ void RifEclipseInputFileTools::saveFaults( QTextStream&       stream,
     const cvf::Collection<RigFault>& faults = mainGrid->faults();
     for ( const auto& fault : faults )
     {
-        if ( fault->name() != RiaResultNames::undefinedGridFaultName() &&
-             fault->name() != RiaResultNames::undefinedGridFaultWithInactiveName() )
+        if ( fault->name() != RiaResultNames::undefinedGridFaultName() && fault->name() != RiaResultNames::undefinedGridFaultWithInactiveName() )
         {
             saveFault( stream, mainGrid, fault->faultFaces(), fault->name(), min, max, refinement );
         }
@@ -726,8 +703,7 @@ bool RifEclipseInputFileTools::importFaultsFromFile( RigEclipseCaseData* eclipse
         for ( size_t i = 0; i < faultCollection.size(); i++ )
         {
             RigFault* f = faultCollection.at( i );
-            if ( f->name() == RiaResultNames::undefinedGridFaultName() ||
-                 f->name() == RiaResultNames::undefinedGridFaultName() )
+            if ( f->name() == RiaResultNames::undefinedGridFaultName() || f->name() == RiaResultNames::undefinedGridFaultName() )
             {
                 // Do not include undefined grid faults, as these are recomputed based on the imported faults from
                 // files
@@ -1061,14 +1037,13 @@ QString RifEclipseInputFileTools::faultFaceText( cvf::StructGridInterface::FaceT
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifEclipseInputFileTools::readFaultsAndParseIncludeStatementsRecursively(
-    QFile&                                          file,
-    qint64                                          startPos,
-    const std::vector<std::pair<QString, QString>>& pathAliasDefinitions,
-    cvf::Collection<RigFault>*                      faults,
-    std::vector<QString>*                           filenamesWithFaults,
-    bool*                                           isEditKeywordDetected,
-    const QString&                                  faultIncludeFileAbsolutePathPrefix )
+bool RifEclipseInputFileTools::readFaultsAndParseIncludeStatementsRecursively( QFile&                                          file,
+                                                                               qint64                                          startPos,
+                                                                               const std::vector<std::pair<QString, QString>>& pathAliasDefinitions,
+                                                                               cvf::Collection<RigFault>*                      faults,
+                                                                               std::vector<QString>* filenamesWithFaults,
+                                                                               bool*                 isEditKeywordDetected,
+                                                                               const QString&        faultIncludeFileAbsolutePathPrefix )
 {
     QString line;
 
@@ -1196,7 +1171,7 @@ bool RifEclipseInputFileTools::readKeywordAndParseIncludeStatementsRecursively(
     QStringList*                                    keywordDataContent,
     std::vector<QString>*                           filenamesContainingKeyword,
     bool*                                           isStopParsingKeywordDetected,
-    const QString& faultIncludeFileAbsolutePathPrefix /* rename to includeStatementAbsolutePathPrefix */ )
+    const QString&                                  faultIncludeFileAbsolutePathPrefix /* rename to includeStatementAbsolutePathPrefix */ )
 {
     QString line;
 
@@ -1318,10 +1293,7 @@ bool RifEclipseInputFileTools::readKeywordAndParseIncludeStatementsRecursively(
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifEclipseInputFileTools::readKeywordDataContent( QFile&       data,
-                                                       qint64       filePos,
-                                                       QStringList* textContent,
-                                                       bool*        isEditKeywordDetected )
+void RifEclipseInputFileTools::readKeywordDataContent( QFile& data, qint64 filePos, QStringList* textContent, bool* isEditKeywordDetected )
 {
     if ( !data.seek( filePos ) )
     {
@@ -1434,10 +1406,7 @@ cvf::StructGridInterface::FaceEnum RifEclipseInputFileTools::faceEnumFromText( c
 /// Parse content of this keyword until end of file or
 /// end of keyword when a single line with '/' is found
 //--------------------------------------------------------------------------------------------------
-void RifEclipseInputFileTools::readFaults( QFile&                     data,
-                                           qint64                     filePos,
-                                           cvf::Collection<RigFault>* faults,
-                                           bool*                      isEditKeywordDetected )
+void RifEclipseInputFileTools::readFaults( QFile& data, qint64 filePos, cvf::Collection<RigFault>* faults, bool* isEditKeywordDetected )
 {
     if ( !data.seek( filePos ) )
     {

ApplicationLibCode/FileInterface/RifEclipseInputFileTools.h

@@ -56,8 +56,7 @@ public:
     RifEclipseInputFileTools();
     ~RifEclipseInputFileTools() override;
 
-    static bool
-        openGridFile( const QString& fileName, RigEclipseCaseData* eclipseCase, bool readFaultData, QString* errorMessages );
+    static bool openGridFile( const QString& fileName, RigEclipseCaseData* eclipseCase, bool readFaultData, QString* errorMessages );
 
     static bool exportGrid( const QString&         gridFileName,
                             RigEclipseCaseData*    eclipseCase,
@@ -105,20 +104,18 @@ public:
                                          const QString&             faultIncludeFileAbsolutePathPrefix );
     static void parseAndReadFaults( const QString& fileName, cvf::Collection<RigFault>* faults );
 
-    static void parseAndReadPathAliasKeyword( const QString&                            fileName,
-                                              std::vector<std::pair<QString, QString>>* pathAliasDefinitions );
+    static void parseAndReadPathAliasKeyword( const QString& fileName, std::vector<std::pair<QString, QString>>* pathAliasDefinitions );
 
-    static bool readKeywordAndParseIncludeStatementsRecursively(
-        const QString&                                  keyword,
-        const QString&                                  keywordToStopParsing,
-        QFile&                                          file,
-        qint64                                          startPos,
-        const std::vector<std::pair<QString, QString>>& pathAliasDefinitions,
-        QStringList*                                    keywordDataContent,
-        std::vector<QString>*                           filenamesContainingKeyword,
-        bool*                                           isEditKeywordDetected,
-        const QString&                                  faultIncludeFileAbsolutePathPrefix // rename to
-                                                          // includeStatementAbsolutePathPrefix
+    static bool readKeywordAndParseIncludeStatementsRecursively( const QString&                                  keyword,
+                                                                 const QString&                                  keywordToStopParsing,
+                                                                 QFile&                                          file,
+                                                                 qint64                                          startPos,
+                                                                 const std::vector<std::pair<QString, QString>>& pathAliasDefinitions,
+                                                                 QStringList*                                    keywordDataContent,
+                                                                 std::vector<QString>*                           filenamesContainingKeyword,
+                                                                 bool*                                           isEditKeywordDetected,
+                                                                 const QString& faultIncludeFileAbsolutePathPrefix // rename to
+                                                                                                                   // includeStatementAbsolutePathPrefix
     );
 
     static RiaDefines::EclipseUnitSystem readUnitSystem( QFile& file, qint64 gridunitPos );
@@ -128,17 +125,14 @@ public:
 private:
     static void readFaults( QFile& data, qint64 filePos, cvf::Collection<RigFault>* faults, bool* isEditKeywordDetected );
 
-    static void readFaults( const QString&                           fileName,
-                            const std::vector<RifKeywordAndFilePos>& fileKeywords,
-                            cvf::Collection<RigFault>*               faults );
-    static bool
-        readFaultsAndParseIncludeStatementsRecursively( QFile&                                          file,
-                                                        qint64                                          startPos,
-                                                        const std::vector<std::pair<QString, QString>>& pathAliasDefinitions,
-                                                        cvf::Collection<RigFault>*                      faults,
-                                                        std::vector<QString>* filenamesWithFaults,
-                                                        bool*                 isEditKeywordDetected,
-                                                        const QString&        faultIncludeFileAbsolutePathPrefix );
+    static void readFaults( const QString& fileName, const std::vector<RifKeywordAndFilePos>& fileKeywords, cvf::Collection<RigFault>* faults );
+    static bool readFaultsAndParseIncludeStatementsRecursively( QFile&                                          file,
+                                                                qint64                                          startPos,
+                                                                const std::vector<std::pair<QString, QString>>& pathAliasDefinitions,
+                                                                cvf::Collection<RigFault>*                      faults,
+                                                                std::vector<QString>*                           filenamesWithFaults,
+                                                                bool*                                           isEditKeywordDetected,
+                                                                const QString& faultIncludeFileAbsolutePathPrefix );
 
     static void readKeywordDataContent( QFile& data, qint64 filePos, QStringList* textContent, bool* isEditKeywordDetected );
 

ApplicationLibCode/FileInterface/RifEclipseInputPropertyLoader.cpp

@@ -35,15 +35,15 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QString RifEclipseInputPropertyLoader::evaluateAndCreateInputPropertyResult( RigEclipseCaseData* eclipseCase,
+QString RifEclipseInputPropertyLoader::evaluateAndCreateInputPropertyResult( RigEclipseCaseData*             eclipseCase,
                                                                              const RifEclipseKeywordContent& keywordContent,
-                                                                             QString* errorMessage )
+                                                                             QString*                        errorMessage )
 {
     auto eclipseKeyword = keywordContent.keyword;
     if ( isInputPropertyCandidate( eclipseCase, eclipseKeyword, keywordContent.values.size(), errorMessage ) )
     {
-        QString newResultName = eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )
-                                    ->makeResultNameUnique( QString::fromStdString( eclipseKeyword ) );
+        QString newResultName =
+            eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->makeResultNameUnique( QString::fromStdString( eclipseKeyword ) );
 
         if ( appendNewInputPropertyResult( eclipseCase, newResultName, eclipseKeyword, keywordContent.values, errorMessage ) )
         {
@@ -57,9 +57,9 @@ QString RifEclipseInputPropertyLoader::evaluateAndCreateInputPropertyResult( Rig
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifEclipseInputPropertyLoader::createInputPropertiesFromKeywords( RigEclipseCaseData* eclipseCase,
+void RifEclipseInputPropertyLoader::createInputPropertiesFromKeywords( RigEclipseCaseData*                          eclipseCase,
                                                                        const std::vector<RifEclipseKeywordContent>& keywordContent,
-                                                                       QString* errorText )
+                                                                       QString*                                     errorText )
 {
     for ( const auto& keywordAndValues : keywordContent )
     {
@@ -98,8 +98,7 @@ bool RifEclipseInputPropertyLoader::isInputPropertyCandidate( const RigEclipseCa
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::map<QString, QString> RifEclipseInputPropertyLoader::readProperties( const QString&      fileName,
-                                                                          RigEclipseCaseData* eclipseCase )
+std::map<QString, QString> RifEclipseInputPropertyLoader::readProperties( const QString& fileName, RigEclipseCaseData* eclipseCase )
 {
     std::map<QString, QString> resultNameAndEclipseNameMap;
 
@@ -180,8 +179,7 @@ bool RifEclipseInputPropertyLoader::appendNewInputPropertyResult( RigEclipseCase
     RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::INPUT_PROPERTY, resultName );
     caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->createResultEntry( resAddr, false );
 
-    auto newPropertyData =
-        caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr );
+    auto newPropertyData = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr );
 
     std::vector<double> doubleVals;
     doubleVals.insert( doubleVals.begin(), values.begin(), values.end() );

ApplicationLibCode/FileInterface/RifEclipseOutputFileTools.cpp

@@ -332,9 +332,7 @@ QString RifEclipseOutputFileTools::firstFileNameOfType( const QStringList& fileS
     {
         bool formatted    = false;
         int  reportNumber = -1;
-        if ( ecl_util_get_file_type( RiaStringEncodingTools::toNativeEncoded( fileSet.at( i ) ).data(),
-                                     &formatted,
-                                     &reportNumber ) == fileType )
+        if ( ecl_util_get_file_type( RiaStringEncodingTools::toNativeEncoded( fileSet.at( i ) ).data(), &formatted, &reportNumber ) == fileType )
         {
             return fileSet.at( i );
         }
@@ -355,9 +353,7 @@ QStringList RifEclipseOutputFileTools::filterFileNamesOfType( const QStringList&
     {
         bool formatted    = false;
         int  reportNumber = -1;
-        if ( ecl_util_get_file_type( RiaStringEncodingTools::toNativeEncoded( fileSet.at( i ) ).data(),
-                                     &formatted,
-                                     &reportNumber ) == fileType )
+        if ( ecl_util_get_file_type( RiaStringEncodingTools::toNativeEncoded( fileSet.at( i ) ).data(), &formatted, &reportNumber ) == fileType )
         {
             fileNames.append( fileSet.at( i ) );
         }
@@ -397,8 +393,7 @@ QByteArray RifEclipseOutputFileTools::md5sum( const QString& fileName )
 //--------------------------------------------------------------------------------------------------
 /// Get set of Eclipse files based on an input file and its path
 //--------------------------------------------------------------------------------------------------
-bool RifEclipseOutputFileTools::findSiblingFilesWithSameBaseName( const QString& fullPathFileName,
-                                                                  QStringList*   baseNameFiles )
+bool RifEclipseOutputFileTools::findSiblingFilesWithSameBaseName( const QString& fullPathFileName, QStringList* baseNameFiles )
 {
     CVF_ASSERT( baseNameFiles );
     baseNameFiles->clear();
@@ -428,8 +423,7 @@ bool RifEclipseOutputFileTools::findSiblingFilesWithSameBaseName( const QString&
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifEclipseOutputFileTools::readGridDimensions( const QString&                 gridFileName,
-                                                    std::vector<std::vector<int>>& gridDimensions )
+void RifEclipseOutputFileTools::readGridDimensions( const QString& gridFileName, std::vector<std::vector<int>>& gridDimensions )
 {
     ecl_grid_type* grid = ecl_grid_alloc( RiaStringEncodingTools::toNativeEncoded( gridFileName ).data() ); // bootstrap
                                                                                                             // ecl_grid
@@ -494,8 +488,7 @@ cvf::ref<RifEclipseRestartDataAccess> RifEclipseOutputFileTools::createDynamicRe
     cvf::ref<RifEclipseRestartDataAccess> resultsAccess;
 
     // Look for unified restart file
-    QString unrstFileName =
-        RifEclipseOutputFileTools::firstFileNameOfType( filesWithSameBaseName, ECL_UNIFIED_RESTART_FILE );
+    QString unrstFileName = RifEclipseOutputFileTools::firstFileNameOfType( filesWithSameBaseName, ECL_UNIFIED_RESTART_FILE );
     if ( unrstFileName.size() > 0 )
     {
         resultsAccess = new RifEclipseUnifiedRestartFileAccess();
@@ -504,8 +497,7 @@ cvf::ref<RifEclipseRestartDataAccess> RifEclipseOutputFileTools::createDynamicRe
     else
     {
         // Look for set of restart files (one file per time step)
-        QStringList restartFiles =
-            RifEclipseOutputFileTools::filterFileNamesOfType( filesWithSameBaseName, ECL_RESTART_FILE );
+        QStringList restartFiles = RifEclipseOutputFileTools::filterFileNamesOfType( filesWithSameBaseName, ECL_RESTART_FILE );
         if ( restartFiles.size() > 0 )
         {
             resultsAccess = new RifEclipseRestartFilesetAccess();
@@ -578,9 +570,7 @@ void RifEclipseOutputFileTools::transferNncFluxData( const ecl_grid_type*      g
         if ( waterFluxData )
         {
             const double* waterFluxValues = ecl_nnc_data_get_values( waterFluxData );
-            waterFlux->insert( waterFlux->end(),
-                               &waterFluxValues[0],
-                               &waterFluxValues[ecl_nnc_data_get_size( waterFluxData )] );
+            waterFlux->insert( waterFlux->end(), &waterFluxValues[0], &waterFluxValues[ecl_nnc_data_get_size( waterFluxData )] );
             ecl_nnc_data_free( waterFluxData );
         }
 
@@ -633,8 +623,8 @@ FILE* RifEclipseOutputFileTools::fopen( const QString& filePath, const QString&
 #pragma warning( disable : 4996 )
 #endif
 
-    FILE* filePtr = std::fopen( RiaStringEncodingTools::toNativeEncoded( filePath ).data(),
-                                RiaStringEncodingTools::toNativeEncoded( mode ).data() );
+    FILE* filePtr =
+        std::fopen( RiaStringEncodingTools::toNativeEncoded( filePath ).data(), RiaStringEncodingTools::toNativeEncoded( mode ).data() );
 
 #ifdef _MSC_VER
 #pragma warning( pop )
@@ -646,8 +636,7 @@ FILE* RifEclipseOutputFileTools::fopen( const QString& filePath, const QString&
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifEclipseOutputFileTools::createReportStepsMetaData( std::vector<ecl_file_type*>        ecl_files,
-                                                           std::vector<RifRestartReportStep>* reportSteps )
+void RifEclipseOutputFileTools::createReportStepsMetaData( std::vector<ecl_file_type*> ecl_files, std::vector<RifRestartReportStep>* reportSteps )
 {
     if ( !reportSteps ) return;
 
@@ -673,8 +662,8 @@ void RifEclipseOutputFileTools::createReportStepsMetaData( std::vector<ecl_file_
 
                     // Set Date
                     {
-                        QDateTime reportDateTime = RiaQDateTimeTools::createDateTime(
-                            QDate( restart_header->year, restart_header->month, restart_header->day ) );
+                        QDateTime reportDateTime =
+                            RiaQDateTimeTools::createDateTime( QDate( restart_header->year, restart_header->month, restart_header->day ) );
                         reportStep.dateTime = reportDateTime;
                     }
 
@@ -689,8 +678,7 @@ void RifEclipseOutputFileTools::createReportStepsMetaData( std::vector<ecl_file_
                         {
                             ecl_data_type dataType     = ecl_file_iget_named_data_type( ecl_file, kw, iOcc );
                             ecl_type_enum dataTypeEmum = ecl_type_get_type( dataType );
-                            if ( dataTypeEmum != ECL_DOUBLE_TYPE && dataTypeEmum != ECL_FLOAT_TYPE &&
-                                 dataTypeEmum != ECL_INT_TYPE )
+                            if ( dataTypeEmum != ECL_DOUBLE_TYPE && dataTypeEmum != ECL_FLOAT_TYPE && dataTypeEmum != ECL_INT_TYPE )
                             {
                                 continue;
                             }

ApplicationLibCode/FileInterface/RifEclipseOutputFileTools.h

@@ -48,18 +48,11 @@ public:
     RifEclipseOutputFileTools();
     virtual ~RifEclipseOutputFileTools();
 
-    static void findKeywordsAndItemCount( std::vector<ecl_file_type*> ecl_files,
-                                          QStringList*                resultNames,
-                                          std::vector<size_t>*        resultDataItemCounts );
+    static void
+        findKeywordsAndItemCount( std::vector<ecl_file_type*> ecl_files, QStringList* resultNames, std::vector<size_t>* resultDataItemCounts );
 
-    static bool keywordData( const ecl_file_type* ecl_file,
-                             const QString&       keyword,
-                             size_t               fileKeywordOccurrence,
-                             std::vector<double>* values );
-    static bool keywordData( const ecl_file_type* ecl_file,
-                             const QString&       keyword,
-                             size_t               fileKeywordOccurrence,
-                             std::vector<int>*    values );
+    static bool keywordData( const ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<double>* values );
+    static bool keywordData( const ecl_file_type* ecl_file, const QString& keyword, size_t fileKeywordOccurrence, std::vector<int>* values );
 
     static void timeSteps( const ecl_file_type*    ecl_file,
                            std::vector<QDateTime>* timeSteps,
@@ -94,6 +87,5 @@ public:
     static FILE* fopen( const QString& filePath, const QString& mode );
 
 private:
-    static void createReportStepsMetaData( std::vector<ecl_file_type*>        ecl_files,
-                                           std::vector<RifRestartReportStep>* reportSteps );
+    static void createReportStepsMetaData( std::vector<ecl_file_type*> ecl_files, std::vector<RifRestartReportStep>* reportSteps );
 };

ApplicationLibCode/FileInterface/RifEclipseRestartDataAccess.h

@@ -92,12 +92,12 @@ public:
     virtual void setRestartFiles( const QStringList& fileSet ) = 0;
     virtual void close()                                       = 0;
 
-    virtual void   setTimeSteps( const std::vector<QDateTime>& timeSteps ){};
-    virtual size_t timeStepCount()                                                                               = 0;
-    virtual void   timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) = 0;
-    virtual std::vector<int> reportNumbers()                                                                     = 0;
+    virtual void             setTimeSteps( const std::vector<QDateTime>& timeSteps ){};
+    virtual size_t           timeStepCount()                                                                               = 0;
+    virtual void             timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) = 0;
+    virtual std::vector<int> reportNumbers()                                                                               = 0;
 
-    virtual void resultNames( QStringList* resultNames, std::vector<size_t>* resultDataItemCounts ) = 0;
+    virtual void resultNames( QStringList* resultNames, std::vector<size_t>* resultDataItemCounts )                   = 0;
     virtual bool results( const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values ) = 0;
 
     virtual bool dynamicNNCResults( const ecl_grid_type* grid,

ApplicationLibCode/FileInterface/RifEclipseRestartFilesetAccess.cpp

@@ -122,8 +122,7 @@ size_t RifEclipseRestartFilesetAccess::timeStepCount()
 //--------------------------------------------------------------------------------------------------
 /// Get the time steps
 //--------------------------------------------------------------------------------------------------
-void RifEclipseRestartFilesetAccess::timeSteps( std::vector<QDateTime>* timeSteps,
-                                                std::vector<double>*    daysSinceSimulationStart )
+void RifEclipseRestartFilesetAccess::timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart )
 {
     if ( m_timeSteps.size() == 0 )
     {
@@ -174,10 +173,7 @@ void RifEclipseRestartFilesetAccess::resultNames( QStringList* resultNames, std:
 //--------------------------------------------------------------------------------------------------
 /// Get result values for given time step
 //--------------------------------------------------------------------------------------------------
-bool RifEclipseRestartFilesetAccess::results( const QString&       resultName,
-                                              size_t               timeStep,
-                                              size_t               gridCount,
-                                              std::vector<double>* values )
+bool RifEclipseRestartFilesetAccess::results( const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values )
 {
     if ( timeStep >= timeStepCount() )
     {
@@ -280,9 +276,8 @@ void RifEclipseRestartFilesetAccess::openTimeStep( size_t timeStep )
 
     if ( m_ecl_files[timeStep] == nullptr )
     {
-        int            index = static_cast<int>( timeStep );
-        ecl_file_type* ecl_file =
-            ecl_file_open( RiaStringEncodingTools::toNativeEncoded( m_fileNames[index] ).data(), ECL_FILE_CLOSE_STREAM );
+        int            index    = static_cast<int>( timeStep );
+        ecl_file_type* ecl_file = ecl_file_open( RiaStringEncodingTools::toNativeEncoded( m_fileNames[index] ).data(), ECL_FILE_CLOSE_STREAM );
 
         m_ecl_files[timeStep] = ecl_file;
 

ApplicationLibCode/FileInterface/RifEclipseRestartFilesetAccess.h

@@ -41,9 +41,9 @@ public:
     void setRestartFiles( const QStringList& fileSet ) override;
     void close() override;
 
-    void   setTimeSteps( const std::vector<QDateTime>& timeSteps ) override;
-    size_t timeStepCount() override;
-    void   timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) override;
+    void             setTimeSteps( const std::vector<QDateTime>& timeSteps ) override;
+    size_t           timeStepCount() override;
+    void             timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) override;
     std::vector<int> reportNumbers() override;
 
     void resultNames( QStringList* resultNames, std::vector<size_t>* resultDataItemCounts ) override;

ApplicationLibCode/FileInterface/RifEclipseRftAddress.cpp

@@ -39,18 +39,13 @@ RifEclipseRftAddress::RifEclipseRftAddress( const QString&            wellName,
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseRftAddress RifEclipseRftAddress::createAddress( const QString&        wellName,
-                                                          const QDateTime&      timeStep,
-                                                          RftWellLogChannelType wellLogChannel )
+RifEclipseRftAddress
+    RifEclipseRftAddress::createAddress( const QString& wellName, const QDateTime& timeStep, RftWellLogChannelType wellLogChannel )
 {
     auto segmentResultName   = "";
     auto segmentBranchNumber = -1;
-    auto adr                 = RifEclipseRftAddress( wellName,
-                                     timeStep,
-                                     wellLogChannel,
-                                     segmentResultName,
-                                     segmentBranchNumber,
-                                     RiaDefines::RftBranchType::RFT_UNKNOWN );
+    auto adr =
+        RifEclipseRftAddress( wellName, timeStep, wellLogChannel, segmentResultName, segmentBranchNumber, RiaDefines::RftBranchType::RFT_UNKNOWN );
 
     return adr;
 }
@@ -77,9 +72,7 @@ RifEclipseRftAddress RifEclipseRftAddress::createBranchSegmentAddress( const QSt
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseRftAddress RifEclipseRftAddress::createSegmentAddress( const QString&   wellName,
-                                                                 const QDateTime& dateTime,
-                                                                 const QString&   resultName )
+RifEclipseRftAddress RifEclipseRftAddress::createSegmentAddress( const QString& wellName, const QDateTime& dateTime, const QString& resultName )
 {
     auto adr = RifEclipseRftAddress( wellName,
                                      dateTime,
@@ -183,12 +176,9 @@ bool operator<( const RifEclipseRftAddress& first, const RifEclipseRftAddress& s
 {
     if ( first.wellName() != second.wellName() ) return ( first.wellName() < second.wellName() );
     if ( first.timeStep() != second.timeStep() ) return ( first.timeStep() < second.timeStep() );
-    if ( first.wellLogChannel() != second.wellLogChannel() )
-        return ( first.wellLogChannel() < second.wellLogChannel() );
-    if ( first.segmentResultName() != second.segmentResultName() )
-        return first.segmentResultName() < second.segmentResultName();
-    if ( first.segmentBranchIndex() != second.segmentBranchIndex() )
-        return first.segmentBranchIndex() < second.segmentBranchIndex();
+    if ( first.wellLogChannel() != second.wellLogChannel() ) return ( first.wellLogChannel() < second.wellLogChannel() );
+    if ( first.segmentResultName() != second.segmentResultName() ) return first.segmentResultName() < second.segmentResultName();
+    if ( first.segmentBranchIndex() != second.segmentBranchIndex() ) return first.segmentBranchIndex() < second.segmentBranchIndex();
 
     return false;
 }

ApplicationLibCode/FileInterface/RifEclipseRftAddress.h

@@ -54,11 +54,9 @@ public:
     };
 
 public:
-    static RifEclipseRftAddress
-        createAddress( const QString& wellName, const QDateTime& timeStep, RftWellLogChannelType wellLogChannel );
+    static RifEclipseRftAddress createAddress( const QString& wellName, const QDateTime& timeStep, RftWellLogChannelType wellLogChannel );
 
-    static RifEclipseRftAddress
-        createSegmentAddress( const QString& wellName, const QDateTime& dateTime, const QString& resultName );
+    static RifEclipseRftAddress createSegmentAddress( const QString& wellName, const QDateTime& dateTime, const QString& resultName );
 
     static RifEclipseRftAddress createBranchSegmentAddress( const QString&            wellName,
                                                             const QDateTime&          dateTime,

ApplicationLibCode/FileInterface/RifEclipseSummaryAddress.cpp

@@ -31,8 +31,7 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress::RifEclipseSummaryAddress( SummaryVarCategory                            category,
-                                                    std::map<SummaryIdentifierType, std::string>& identifiers )
+RifEclipseSummaryAddress::RifEclipseSummaryAddress( SummaryVarCategory category, std::map<SummaryIdentifierType, std::string>& identifiers )
     : m_variableCategory( category )
     , m_regionNumber( -1 )
     , m_regionNumber2( -1 )
@@ -217,8 +216,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::fieldAddress( const std::stri
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress
-    RifEclipseSummaryAddress::aquiferAddress( const std::string& vectorName, int aquiferNumber, int calculationId )
+RifEclipseSummaryAddress RifEclipseSummaryAddress::aquiferAddress( const std::string& vectorName, int aquiferNumber, int calculationId )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_AQUIFER;
@@ -255,8 +253,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::miscAddress( const std::strin
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress
-    RifEclipseSummaryAddress::regionAddress( const std::string& vectorName, int regionNumber, int calculationId )
+RifEclipseSummaryAddress RifEclipseSummaryAddress::regionAddress( const std::string& vectorName, int regionNumber, int calculationId )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_REGION;
@@ -269,10 +266,8 @@ RifEclipseSummaryAddress
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress RifEclipseSummaryAddress::regionToRegionAddress( const std::string& vectorName,
-                                                                          int                regionNumber,
-                                                                          int                region2Number,
-                                                                          int                calculationId )
+RifEclipseSummaryAddress
+    RifEclipseSummaryAddress::regionToRegionAddress( const std::string& vectorName, int regionNumber, int region2Number, int calculationId )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_REGION_2_REGION;
@@ -286,8 +281,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::regionToRegionAddress( const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress
-    RifEclipseSummaryAddress::groupAddress( const std::string& vectorName, const std::string& groupName, int calculationId )
+RifEclipseSummaryAddress RifEclipseSummaryAddress::groupAddress( const std::string& vectorName, const std::string& groupName, int calculationId )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_GROUP;
@@ -300,8 +294,7 @@ RifEclipseSummaryAddress
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress
-    RifEclipseSummaryAddress::wellAddress( const std::string& vectorName, const std::string& wellName, int calculationId )
+RifEclipseSummaryAddress RifEclipseSummaryAddress::wellAddress( const std::string& vectorName, const std::string& wellName, int calculationId )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_WELL;
@@ -314,12 +307,8 @@ RifEclipseSummaryAddress
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionAddress( const std::string& vectorName,
-                                                                          const std::string& wellName,
-                                                                          int                i,
-                                                                          int                j,
-                                                                          int                k,
-                                                                          int                calculationId )
+RifEclipseSummaryAddress
+    RifEclipseSummaryAddress::wellCompletionAddress( const std::string& vectorName, const std::string& wellName, int i, int j, int k, int calculationId )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_WELL_COMPLETION;
@@ -375,10 +364,8 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionLgrAddress( con
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress RifEclipseSummaryAddress::wellSegmentAddress( const std::string& vectorName,
-                                                                       const std::string& wellName,
-                                                                       int                segmentNumber,
-                                                                       int                calculationId )
+RifEclipseSummaryAddress
+    RifEclipseSummaryAddress::wellSegmentAddress( const std::string& vectorName, const std::string& wellName, int segmentNumber, int calculationId )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory  = SUMMARY_WELL_SEGMENT;
@@ -392,8 +379,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellSegmentAddress( const std
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress
-    RifEclipseSummaryAddress::blockAddress( const std::string& vectorName, int i, int j, int k, int calculationId )
+RifEclipseSummaryAddress RifEclipseSummaryAddress::blockAddress( const std::string& vectorName, int i, int j, int k, int calculationId )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_BLOCK;
@@ -408,12 +394,8 @@ RifEclipseSummaryAddress
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress RifEclipseSummaryAddress::blockLgrAddress( const std::string& vectorName,
-                                                                    const std::string& lgrName,
-                                                                    int                i,
-                                                                    int                j,
-                                                                    int                k,
-                                                                    int                calculationId )
+RifEclipseSummaryAddress
+    RifEclipseSummaryAddress::blockLgrAddress( const std::string& vectorName, const std::string& lgrName, int i, int j, int k, int calculationId )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_BLOCK_LGR;
@@ -440,8 +422,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::importedAddress( const std::s
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress RifEclipseSummaryAddress::ensembleStatisticsAddress( const std::string& vectorName,
-                                                                              const std::string& dataQuantityName )
+RifEclipseSummaryAddress RifEclipseSummaryAddress::ensembleStatisticsAddress( const std::string& vectorName, const std::string& dataQuantityName )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_ENSEMBLE_STATISTICS;
@@ -453,7 +434,7 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::ensembleStatisticsAddress( co
 ///
 //--------------------------------------------------------------------------------------------------
 std::string RifEclipseSummaryAddress::generateStringFromAddresses( const std::vector<RifEclipseSummaryAddress>& addressVector,
-                                                                   const std::string jointString )
+                                                                   const std::string                            jointString )
 {
     std::string addrString;
     for ( RifEclipseSummaryAddress address : addressVector )
@@ -614,8 +595,7 @@ std::string RifEclipseSummaryAddress::itemUiText() const
 //--------------------------------------------------------------------------------------------------
 /// Returns the stringified address component requested
 //--------------------------------------------------------------------------------------------------
-std::string
-    RifEclipseSummaryAddress::addressComponentUiText( RifEclipseSummaryAddress::SummaryIdentifierType identifierType ) const
+std::string RifEclipseSummaryAddress::addressComponentUiText( RifEclipseSummaryAddress::SummaryIdentifierType identifierType ) const
 {
     switch ( identifierType )
     {

ApplicationLibCode/FileInterface/RifEclipseSummaryAddress.h

@@ -99,28 +99,19 @@ public:
     static RifEclipseSummaryAddress fromEclipseTextAddressParseErrorTokens( const std::string& textAddress );
 
     static RifEclipseSummaryAddress fieldAddress( const std::string& vectorName, int calculationId = -1 );
-    static RifEclipseSummaryAddress
-                                    aquiferAddress( const std::string& vectorName, int aquiferNumber, int calculationId = -1 );
+    static RifEclipseSummaryAddress aquiferAddress( const std::string& vectorName, int aquiferNumber, int calculationId = -1 );
     static RifEclipseSummaryAddress networkAddress( const std::string& vectorName, int calculationId = -1 );
     static RifEclipseSummaryAddress miscAddress( const std::string& vectorName, int calculationId = -1 );
     static RifEclipseSummaryAddress regionAddress( const std::string& vectorName, int regionNumber, int calculationId = -1 );
     static RifEclipseSummaryAddress
-        regionToRegionAddress( const std::string& vectorName, int regionNumber, int region2Number, int calculationId = -1 );
-    static RifEclipseSummaryAddress
-        groupAddress( const std::string& vectorName, const std::string& groupName, int calculationId = -1 );
-    static RifEclipseSummaryAddress
-        wellAddress( const std::string& vectorName, const std::string& wellName, int calculationId = -1 );
+                                    regionToRegionAddress( const std::string& vectorName, int regionNumber, int region2Number, int calculationId = -1 );
+    static RifEclipseSummaryAddress groupAddress( const std::string& vectorName, const std::string& groupName, int calculationId = -1 );
+    static RifEclipseSummaryAddress wellAddress( const std::string& vectorName, const std::string& wellName, int calculationId = -1 );
 
-    static RifEclipseSummaryAddress wellCompletionAddress( const std::string& vectorName,
-                                                           const std::string& wellName,
-                                                           int                i,
-                                                           int                j,
-                                                           int                k,
-                                                           int                calculationId = -1 );
-    static RifEclipseSummaryAddress wellLgrAddress( const std::string& vectorName,
-                                                    const std::string& lgrName,
-                                                    const std::string& wellName,
-                                                    int                calculationId = -1 );
+    static RifEclipseSummaryAddress
+        wellCompletionAddress( const std::string& vectorName, const std::string& wellName, int i, int j, int k, int calculationId = -1 );
+    static RifEclipseSummaryAddress
+                                    wellLgrAddress( const std::string& vectorName, const std::string& lgrName, const std::string& wellName, int calculationId = -1 );
     static RifEclipseSummaryAddress wellCompletionLgrAddress( const std::string& vectorName,
                                                               const std::string& lgrName,
                                                               const std::string& wellName,
@@ -128,21 +119,13 @@ public:
                                                               int                j,
                                                               int                k,
                                                               int                calculationId = -1 );
-    static RifEclipseSummaryAddress wellSegmentAddress( const std::string& vectorName,
-                                                        const std::string& wellName,
-                                                        int                segmentNumber,
-                                                        int                calculationId = -1 );
     static RifEclipseSummaryAddress
-                                    blockAddress( const std::string& vectorName, int i, int j, int k, int calculationId = -1 );
-    static RifEclipseSummaryAddress blockLgrAddress( const std::string& vectorName,
-                                                     const std::string& lgrName,
-                                                     int                i,
-                                                     int                j,
-                                                     int                k,
-                                                     int                calculationId = -1 );
+                                    wellSegmentAddress( const std::string& vectorName, const std::string& wellName, int segmentNumber, int calculationId = -1 );
+    static RifEclipseSummaryAddress blockAddress( const std::string& vectorName, int i, int j, int k, int calculationId = -1 );
+    static RifEclipseSummaryAddress
+                                    blockLgrAddress( const std::string& vectorName, const std::string& lgrName, int i, int j, int k, int calculationId = -1 );
     static RifEclipseSummaryAddress importedAddress( const std::string& vectorName );
-    static RifEclipseSummaryAddress ensembleStatisticsAddress( const std::string& vectorName,
-                                                               const std::string& datavectorName );
+    static RifEclipseSummaryAddress ensembleStatisticsAddress( const std::string& vectorName, const std::string& datavectorName );
 
     static std::string generateStringFromAddresses( const std::vector<RifEclipseSummaryAddress>& addressVector,
                                                     const std::string                            jointString = "; " );

ApplicationLibCode/FileInterface/RifEclipseSummaryTools.cpp

@@ -138,11 +138,9 @@ void RifEclipseSummaryTools::dumpMetaData( RifSummaryReaderInterface* readerEcli
 
     for ( int category = 0; category < RifEclipseSummaryAddress::SUMMARY_BLOCK_LGR; category++ )
     {
-        RifEclipseSummaryAddress::SummaryVarCategory categoryEnum =
-            RifEclipseSummaryAddress::SummaryVarCategory( category );
+        RifEclipseSummaryAddress::SummaryVarCategory categoryEnum = RifEclipseSummaryAddress::SummaryVarCategory( category );
 
-        std::vector<RifEclipseSummaryAddress> catAddresses =
-            RiaSummaryAddressAnalyzer::addressesForCategory( addresses, categoryEnum );
+        std::vector<RifEclipseSummaryAddress> catAddresses = RiaSummaryAddressAnalyzer::addressesForCategory( addresses, categoryEnum );
 
         if ( !catAddresses.empty() )
         {
@@ -151,11 +149,10 @@ void RifEclipseSummaryTools::dumpMetaData( RifSummaryReaderInterface* readerEcli
 
             for ( const auto& catAddresse : catAddresses )
             {
-                std::cout << catAddresse.vectorName() << " " << catAddresse.regionNumber() << " "
-                          << catAddresse.regionNumber2() << " " << catAddresse.groupName() << " "
-                          << catAddresse.wellName() << " " << catAddresse.wellSegmentNumber() << " "
-                          << catAddresse.lgrName() << " " << catAddresse.cellI() << " " << catAddresse.cellJ() << " "
-                          << catAddresse.cellK() << std::endl;
+                std::cout << catAddresse.vectorName() << " " << catAddresse.regionNumber() << " " << catAddresse.regionNumber2() << " "
+                          << catAddresse.groupName() << " " << catAddresse.wellName() << " " << catAddresse.wellSegmentNumber() << " "
+                          << catAddresse.lgrName() << " " << catAddresse.cellI() << " " << catAddresse.cellJ() << " " << catAddresse.cellK()
+                          << std::endl;
             }
 
             std::cout << std::endl;
@@ -166,8 +163,7 @@ void RifEclipseSummaryTools::dumpMetaData( RifSummaryReaderInterface* readerEcli
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RifRestartFileInfo> RifEclipseSummaryTools::getRestartFiles( const QString&        headerFileName,
-                                                                         std::vector<QString>& warnings )
+std::vector<RifRestartFileInfo> RifEclipseSummaryTools::getRestartFiles( const QString& headerFileName, std::vector<QString>& warnings )
 {
     std::vector<RifRestartFileInfo> restartFiles;
 
@@ -197,11 +193,10 @@ std::vector<RifRestartFileInfo> RifEclipseSummaryTools::getRestartFiles( const Q
                 if ( formattedHeaderFileInfo.lastModified() < nonformattedHeaderFileInfo.lastModified() &&
                      formattedHeaderFileInfo.exists() && !formattedDateFileInfo.exists() )
                 {
-                    warnings.push_back(
-                        QString( "RifReaderEclipseSummary: Formatted summary header file without an\n" ) +
-                        QString( "associated data file detected.\n" ) +
-                        QString( "This may cause a failure reading summary origin data.\n" ) +
-                        QString( "To avoid this problem, please delete or rename the.FSMSPEC file." ) );
+                    warnings.push_back( QString( "RifReaderEclipseSummary: Formatted summary header file without an\n" ) +
+                                        QString( "associated data file detected.\n" ) +
+                                        QString( "This may cause a failure reading summary origin data.\n" ) +
+                                        QString( "To avoid this problem, please delete or rename the.FSMSPEC file." ) );
                     break;
                 }
             }
@@ -248,20 +243,13 @@ RifRestartFileInfo RifEclipseSummaryTools::getFileInfo( const QString& headerFil
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifEclipseSummaryTools::findSummaryHeaderFileInfo( const QString& inputFile,
-                                                        QString*       headerFile,
-                                                        QString*       path,
-                                                        QString*       base,
-                                                        bool*          isFormatted )
+void RifEclipseSummaryTools::findSummaryHeaderFileInfo( const QString& inputFile, QString* headerFile, QString* path, QString* base, bool* isFormatted )
 {
     char* myPath        = nullptr;
     char* myBase        = nullptr;
     bool  formattedFile = true;
 
-    util_alloc_file_components( RiaStringEncodingTools::toNativeEncoded( QDir::toNativeSeparators( inputFile ) ).data(),
-                                &myPath,
-                                &myBase,
-                                nullptr );
+    util_alloc_file_components( RiaStringEncodingTools::toNativeEncoded( QDir::toNativeSeparators( inputFile ) ).data(), &myPath, &myBase, nullptr );
 
     char* myHeaderFile = ecl_util_alloc_exfilename( myPath, myBase, ECL_SUMMARY_HEADER_FILE, true, -1 );
     if ( !myHeaderFile )
@@ -292,8 +280,7 @@ RifRestartFileInfo RifEclipseSummaryTools::getRestartFile( const QString& header
 
     const ecl_smspec_type* smspec  = ecl_sum ? ecl_sum_get_smspec( ecl_sum ) : nullptr;
     const char*            rstCase = smspec ? ecl_smspec_get_restart_case( smspec ) : nullptr;
-    QString                restartCase =
-        rstCase ? RiaFilePathTools::canonicalPath( RiaStringEncodingTools::fromNativeEncoded( rstCase ) ) : "";
+    QString restartCase            = rstCase ? RiaFilePathTools::canonicalPath( RiaStringEncodingTools::fromNativeEncoded( rstCase ) ) : "";
     closeEclSum( ecl_sum );
 
     if ( !restartCase.isEmpty() )
@@ -301,13 +288,12 @@ RifRestartFileInfo RifEclipseSummaryTools::getRestartFile( const QString& header
         QString path        = QFileInfo( restartCase ).dir().path();
         QString restartBase = QDir( restartCase ).dirName();
 
-        char*   smspec_header = ecl_util_alloc_exfilename( path.toStdString().data(),
+        char*   smspec_header   = ecl_util_alloc_exfilename( path.toStdString().data(),
                                                          restartBase.toStdString().data(),
                                                          ECL_SUMMARY_HEADER_FILE,
                                                          false /*unformatted*/,
                                                          0 );
-        QString restartFileName =
-            RiaFilePathTools::toInternalSeparator( RiaStringEncodingTools::fromNativeEncoded( smspec_header ) );
+        QString restartFileName = RiaFilePathTools::toInternalSeparator( RiaStringEncodingTools::fromNativeEncoded( smspec_header ) );
         free( smspec_header );
 
         return getFileInfo( restartFileName );

ApplicationLibCode/FileInterface/RifEclipseSummaryTools.h

@@ -81,9 +81,5 @@ private:
     static void               findSummaryFiles( const QString& inputFile, QString* headerFile, QStringList* dataFiles );
     static RifRestartFileInfo getRestartFile( const QString& headerFileName );
 
-    static void findSummaryHeaderFileInfo( const QString& inputFile,
-                                           QString*       headerFile,
-                                           QString*       path,
-                                           QString*       base,
-                                           bool*          isFormatted );
+    static void findSummaryHeaderFileInfo( const QString& inputFile, QString* headerFile, QString* path, QString* base, bool* isFormatted );
 };

ApplicationLibCode/FileInterface/RifEclipseTextFileReader.cpp

@@ -39,8 +39,7 @@
 //--------------------------------------------------------------------------------------------------
 std::vector<RifEclipseKeywordContent> RifEclipseTextFileReader::readKeywordAndValues( const std::string& filename )
 {
-    if ( RiaPreferencesSystem::current()->eclipseTextFileReaderMode() ==
-         RiaPreferencesSystem::EclipseTextFileReaderMode::MEMORY_MAPPED_FILE )
+    if ( RiaPreferencesSystem::current()->eclipseTextFileReaderMode() == RiaPreferencesSystem::EclipseTextFileReaderMode::MEMORY_MAPPED_FILE )
     {
         return readKeywordAndValuesMemoryMappedFile( filename );
     }
@@ -69,8 +68,7 @@ std::vector<RifEclipseKeywordContent> RifEclipseTextFileReader::readKeywordAndVa
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RifEclipseKeywordContent>
-    RifEclipseTextFileReader::readKeywordAndValuesMemoryMappedFile( const std::string& filename )
+std::vector<RifEclipseKeywordContent> RifEclipseTextFileReader::readKeywordAndValuesMemoryMappedFile( const std::string& filename )
 {
     if ( !std::filesystem::exists( filename ) ) return {};
 

ApplicationLibCode/FileInterface/RifEclipseUnifiedRestartFileAccess.cpp

@@ -103,8 +103,7 @@ bool RifEclipseUnifiedRestartFileAccess::openFile()
 
         if ( !m_ecl_file )
         {
-            m_ecl_file =
-                ecl_file_open( RiaStringEncodingTools::toNativeEncoded( m_filename ).data(), ECL_FILE_CLOSE_STREAM );
+            m_ecl_file = ecl_file_open( RiaStringEncodingTools::toNativeEncoded( m_filename ).data(), ECL_FILE_CLOSE_STREAM );
             if ( !m_ecl_file )
             {
                 RiaLogging::error( QString( "Failed to open file %1" ).arg( m_filename ) );
@@ -117,9 +116,7 @@ bool RifEclipseUnifiedRestartFileAccess::openFile()
                     QString   resultPath = fi.absolutePath();
                     if ( caf::Utils::isFolderWritable( resultPath ) )
                     {
-                        bool success =
-                            ecl_file_write_index( m_ecl_file,
-                                                  RiaStringEncodingTools::toNativeEncoded( indexFileName ).data() );
+                        bool success = ecl_file_write_index( m_ecl_file, RiaStringEncodingTools::toNativeEncoded( indexFileName ).data() );
 
                         if ( success )
                         {
@@ -212,8 +209,7 @@ size_t RifEclipseUnifiedRestartFileAccess::timeStepCount()
 //--------------------------------------------------------------------------------------------------
 /// Get the time steps
 //--------------------------------------------------------------------------------------------------
-void RifEclipseUnifiedRestartFileAccess::timeSteps( std::vector<QDateTime>* timeSteps,
-                                                    std::vector<double>*    daysSinceSimulationStart )
+void RifEclipseUnifiedRestartFileAccess::timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart )
 {
     if ( m_timeSteps.size() == 0 )
     {
@@ -234,19 +230,14 @@ void RifEclipseUnifiedRestartFileAccess::resultNames( QStringList* resultNames,
         std::vector<ecl_file_type*> filesUsedToFindAvailableKeywords;
         filesUsedToFindAvailableKeywords.push_back( m_ecl_file );
 
-        RifEclipseOutputFileTools::findKeywordsAndItemCount( filesUsedToFindAvailableKeywords,
-                                                             resultNames,
-                                                             resultDataItemCounts );
+        RifEclipseOutputFileTools::findKeywordsAndItemCount( filesUsedToFindAvailableKeywords, resultNames, resultDataItemCounts );
     }
 }
 
 //--------------------------------------------------------------------------------------------------
 /// Get result values for given time step
 //--------------------------------------------------------------------------------------------------
-bool RifEclipseUnifiedRestartFileAccess::results( const QString&       resultName,
-                                                  size_t               timeStep,
-                                                  size_t               gridCount,
-                                                  std::vector<double>* values )
+bool RifEclipseUnifiedRestartFileAccess::results( const QString& resultName, size_t timeStep, size_t gridCount, std::vector<double>* values )
 {
     if ( !openFile() )
     {

ApplicationLibCode/FileInterface/RifEclipseUnifiedRestartFileAccess.h

@@ -43,8 +43,8 @@ public:
     bool open() override;
     void close() override;
 
-    size_t timeStepCount() override;
-    void   timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) override;
+    size_t           timeStepCount() override;
+    void             timeSteps( std::vector<QDateTime>* timeSteps, std::vector<double>* daysSinceSimulationStart ) override;
     std::vector<int> reportNumbers() override;
 
     void resultNames( QStringList* resultNames, std::vector<size_t>* resultDataItemCounts ) override;

ApplicationLibCode/FileInterface/RifEclipseUserDataKeywordTools.cpp

@@ -163,11 +163,10 @@ bool RifEclipseUserDataKeywordTools::isYearX( const std::string& identifier )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress RifEclipseUserDataKeywordTools::makeAndFillAddress( const std::string quantityName,
+RifEclipseSummaryAddress RifEclipseUserDataKeywordTools::makeAndFillAddress( const std::string               quantityName,
                                                                              const std::vector<std::string>& columnHeaderText )
 {
-    RifEclipseSummaryAddress::SummaryVarCategory category =
-        RiuSummaryQuantityNameInfoProvider::instance()->identifyCategory( quantityName );
+    RifEclipseSummaryAddress::SummaryVarCategory category = RiuSummaryQuantityNameInfoProvider::instance()->identifyCategory( quantityName );
 
     if ( category == RifEclipseSummaryAddress::SUMMARY_INVALID )
     {

ApplicationLibCode/FileInterface/RifEclipseUserDataKeywordTools.h

@@ -31,10 +31,9 @@ class RifEclipseUserDataKeywordTools
 public:
     static std::vector<size_t> requiredItemsPerLineForKeyword( const std::string& identifier );
 
-    static std::vector<std::vector<std::string>>
-        buildColumnHeaderText( const std::vector<std::string>&              quantityNames,
-                               const std::vector<std::vector<std::string>>& restOfHeaderRows,
-                               std::vector<std::string>*                    errorText = nullptr );
+    static std::vector<std::vector<std::string>> buildColumnHeaderText( const std::vector<std::string>&              quantityNames,
+                                                                        const std::vector<std::vector<std::string>>& restOfHeaderRows,
+                                                                        std::vector<std::string>*                    errorText = nullptr );
 
     static bool isTime( const std::string& identifier );
     static bool isDate( const std::string& identifier );
@@ -42,8 +41,7 @@ public:
     static bool isYears( const std::string& identifier );
     static bool isYearX( const std::string& identifier );
 
-    static RifEclipseSummaryAddress makeAndFillAddress( const std::string               quantityName,
-                                                        const std::vector<std::string>& columnHeaderText );
+    static RifEclipseSummaryAddress makeAndFillAddress( const std::string quantityName, const std::vector<std::string>& columnHeaderText );
 
     static bool   isStepType( const std::string& identifier );
     static size_t computeRequiredHeaderLineCount( const std::vector<std::string>& words );

ApplicationLibCode/FileInterface/RifEclipseUserDataParserTools.cpp

@@ -117,10 +117,7 @@ std::vector<std::string> RifEclipseUserDataParserTools::splitLineAndRemoveCommen
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifEclipseUserDataParserTools::keywordParser( const std::string& line,
-                                                   std::string&       origin,
-                                                   std::string&       dateFormat,
-                                                   std::string&       startDate )
+bool RifEclipseUserDataParserTools::keywordParser( const std::string& line, std::string& origin, std::string& dateFormat, std::string& startDate )
 {
     std::vector<std::string> words = splitLineAndRemoveComments( line );
     if ( words.size() < 2 ) return false;
@@ -229,8 +226,7 @@ bool RifEclipseUserDataParserTools::hasTimeUnit( const std::string& word )
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifEclipseUserDataParserTools::hasOnlyValidDoubleValues( const std::vector<std::string>& words,
-                                                              std::vector<double>*            doubleValues )
+bool RifEclipseUserDataParserTools::hasOnlyValidDoubleValues( const std::vector<std::string>& words, std::vector<double>* doubleValues )
 {
     bool onlyValidValues = true;
 
@@ -283,8 +279,7 @@ bool RifEclipseUserDataParserTools::isValidTableData( size_t columnCount, const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-TableData RifEclipseUserDataParserTools::tableDataFromText( std::stringstream&        streamData,
-                                                            std::vector<std::string>* errorText )
+TableData RifEclipseUserDataParserTools::tableDataFromText( std::stringstream& streamData, std::vector<std::string>* errorText )
 {
     TableData emptyTable;
 
@@ -435,8 +430,7 @@ TableData RifEclipseUserDataParserTools::tableDataFromText( std::stringstream&
 
             std::vector<std::string> columnHeader;
 
-            if ( columnText.size() > 1 )
-                columnHeader.insert( columnHeader.begin(), columnText.begin() + 1, columnText.end() );
+            if ( columnText.size() > 1 ) columnHeader.insert( columnHeader.begin(), columnText.begin() + 1, columnText.end() );
 
             RifEclipseSummaryAddress adr = RifEclipseUserDataKeywordTools::makeAndFillAddress( vectorName, columnHeader );
 
@@ -547,8 +541,7 @@ std::vector<std::string> RifEclipseUserDataParserTools::findValidHeaderLines( st
 
                     columnCount = words.size();
 
-                    minimunRequiredExtraHeaderLines =
-                        RifEclipseUserDataKeywordTools::computeRequiredHeaderLineCount( words );
+                    minimunRequiredExtraHeaderLines = RifEclipseUserDataKeywordTools::computeRequiredHeaderLineCount( words );
 
                     headerLines.push_back( line );
                 }
@@ -589,8 +582,7 @@ std::vector<std::string> RifEclipseUserDataParserTools::findValidHeaderLines( st
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<std::vector<std::string>>
-    RifEclipseUserDataParserTools::splitIntoColumnHeaders( const std::vector<std::string>& headerLines )
+std::vector<std::vector<std::string>> RifEclipseUserDataParserTools::splitIntoColumnHeaders( const std::vector<std::string>& headerLines )
 {
     std::vector<std::vector<std::string>> headerLinesPerColumn;
 
@@ -622,8 +614,7 @@ std::vector<std::vector<std::string>>
                     }
 
                     std::string subString;
-                    if ( columnWidth != std::string::npos && colStart < headerLine.size() &&
-                         colStart + columnWidth <= headerLine.size() )
+                    if ( columnWidth != std::string::npos && colStart < headerLine.size() && colStart + columnWidth <= headerLine.size() )
                     {
                         subString = headerLine.substr( colStart, columnWidth );
                     }
@@ -642,8 +633,7 @@ std::vector<std::vector<std::string>>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<Column>
-    RifEclipseUserDataParserTools::columnInfoFromColumnHeaders( const std::vector<std::vector<std::string>>& columnData )
+std::vector<Column> RifEclipseUserDataParserTools::columnInfoFromColumnHeaders( const std::vector<std::vector<std::string>>& columnData )
 {
     std::vector<Column> table;
 
@@ -781,8 +771,7 @@ std::vector<TableData> RifEclipseUserDataParserTools::mergeEqualTimeSteps( const
             }
         }
 
-        if ( tables[i].columnInfos().size() > 0 && tables[i].columnInfos()[0].itemCount() == itemsInFirstTable &&
-             isDatesEqual )
+        if ( tables[i].columnInfos().size() > 0 && tables[i].columnInfos()[0].itemCount() == itemsInFirstTable && isDatesEqual )
         {
             for ( auto& c : tables[i].columnInfos() )
             {
@@ -866,9 +855,7 @@ size_t Column::itemCount() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-Column Column::createColumnInfoFromRsmData( const std::string&              vectorName,
-                                            const std::string&              unit,
-                                            const RifEclipseSummaryAddress& addr )
+Column Column::createColumnInfoFromRsmData( const std::string& vectorName, const std::string& unit, const RifEclipseSummaryAddress& addr )
 {
     Column ci( addr, unit );
 

ApplicationLibCode/FileInterface/RifEclipseUserDataParserTools.h

@@ -60,9 +60,7 @@ public:
     size_t      itemCount() const;
 
 public:
-    static Column createColumnInfoFromRsmData( const std::string&              vectorName,
-                                               const std::string&              unit,
-                                               const RifEclipseSummaryAddress& addr );
+    static Column createColumnInfoFromRsmData( const std::string& vectorName, const std::string& unit, const RifEclipseSummaryAddress& addr );
     static Column createColumnInfoFromCsvData( const RifEclipseSummaryAddress& addr, const std::string& unit );
 
     RifEclipseSummaryAddress summaryAddress;
@@ -132,14 +130,12 @@ public:
     static bool                     isAComment( const std::string& word );
     static std::vector<std::string> splitLineAndRemoveComments( const std::string& line );
     static std::vector<double>      splitLineToDoubles( const std::string& line );
-    static bool
-                                    keywordParser( const std::string& line, std::string& origin, std::string& dateFormat, std::string& startDate );
-    static bool                     isANumber( const std::string& line );
+    static bool keywordParser( const std::string& line, std::string& origin, std::string& dateFormat, std::string& startDate );
+    static bool isANumber( const std::string& line );
     static std::vector<std::string> headerReader( std::stringstream& streamData, std::string& line );
 
     static bool hasTimeUnit( const std::string& line );
-    static bool hasOnlyValidDoubleValues( const std::vector<std::string>& words,
-                                          std::vector<double>*            doubleValues = nullptr );
+    static bool hasOnlyValidDoubleValues( const std::vector<std::string>& words, std::vector<double>* doubleValues = nullptr );
 
     static bool isValidTableData( size_t columnCount, const std::string& line );
 
@@ -151,8 +147,8 @@ public:
     static std::vector<Column>                   columnInfoForFixedColumnWidth( std::stringstream& streamData );
     static std::vector<std::string>              findValidHeaderLines( std::stringstream& streamData );
     static std::vector<std::vector<std::string>> splitIntoColumnHeaders( const std::vector<std::string>& headerLines );
-    static std::vector<Column> columnInfoFromColumnHeaders( const std::vector<std::vector<std::string>>& columnData );
-    static std::vector<size_t> columnIndexForWords( const std::string& line );
+    static std::vector<Column>                   columnInfoFromColumnHeaders( const std::vector<std::vector<std::string>>& columnData );
+    static std::vector<size_t>                   columnIndexForWords( const std::string& line );
 
     static std::vector<TableData> mergeEqualTimeSteps( const std::vector<TableData>& tables );
 

ApplicationLibCode/FileInterface/RifElasticPropertiesReader.cpp

@@ -76,10 +76,8 @@ void RifElasticPropertiesReader::readElasticProperties( std::vector<RifElasticPr
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifElasticProperties RifElasticPropertiesReader::parseElasticProperties( const QString& line,
-                                                                         int            lineNumber,
-                                                                         const QString& filePath,
-                                                                         const QString& separator )
+RifElasticProperties
+    RifElasticPropertiesReader::parseElasticProperties( const QString& line, int lineNumber, const QString& filePath, const QString& separator )
 {
     QStringList tokens = tokenize( line, separator );
 
@@ -108,20 +106,19 @@ RifElasticProperties RifElasticPropertiesReader::parseElasticProperties( const Q
     verifyNonEmptyTokens( tokens, nameOfNonEmptyTokens, lineNumber, filePath );
 
     RifElasticProperties elasticProperties;
-    elasticProperties.fieldName            = tokens[0];
-    elasticProperties.formationName        = tokens[1];
-    elasticProperties.faciesName           = tokens[2];
-    elasticProperties.porosity             = parseDouble( tokens[3], "Porosity", lineNumber, filePath );
-    elasticProperties.youngsModulus        = parseDouble( tokens[4], "Young's Modulus", lineNumber, filePath );
-    elasticProperties.poissonsRatio        = parseDouble( tokens[5], "Poisson's Ratio", lineNumber, filePath );
-    elasticProperties.K_Ic                 = parseDouble( tokens[6], "K-Ic", lineNumber, filePath );
-    elasticProperties.proppantEmbedment    = parseDouble( tokens[7], "Proppant Embedment", lineNumber, filePath );
-    elasticProperties.biotCoefficient      = parseDouble( tokens[8], "Biot Coefficient", lineNumber, filePath );
-    elasticProperties.k0                   = parseDouble( tokens[9], "k0", lineNumber, filePath );
-    elasticProperties.fluidLossCoefficient = parseDouble( tokens[10], "Fluid Loss Coefficient", lineNumber, filePath );
-    elasticProperties.spurtLoss            = parseDouble( tokens[11], "Spurt Loss", lineNumber, filePath );
-    elasticProperties.immobileFluidSaturation =
-        parseDouble( tokens[12], "Immobile Fluid Saturation", lineNumber, filePath );
+    elasticProperties.fieldName               = tokens[0];
+    elasticProperties.formationName           = tokens[1];
+    elasticProperties.faciesName              = tokens[2];
+    elasticProperties.porosity                = parseDouble( tokens[3], "Porosity", lineNumber, filePath );
+    elasticProperties.youngsModulus           = parseDouble( tokens[4], "Young's Modulus", lineNumber, filePath );
+    elasticProperties.poissonsRatio           = parseDouble( tokens[5], "Poisson's Ratio", lineNumber, filePath );
+    elasticProperties.K_Ic                    = parseDouble( tokens[6], "K-Ic", lineNumber, filePath );
+    elasticProperties.proppantEmbedment       = parseDouble( tokens[7], "Proppant Embedment", lineNumber, filePath );
+    elasticProperties.biotCoefficient         = parseDouble( tokens[8], "Biot Coefficient", lineNumber, filePath );
+    elasticProperties.k0                      = parseDouble( tokens[9], "k0", lineNumber, filePath );
+    elasticProperties.fluidLossCoefficient    = parseDouble( tokens[10], "Fluid Loss Coefficient", lineNumber, filePath );
+    elasticProperties.spurtLoss               = parseDouble( tokens[11], "Spurt Loss", lineNumber, filePath );
+    elasticProperties.immobileFluidSaturation = parseDouble( tokens[12], "Immobile Fluid Saturation", lineNumber, filePath );
 
     return elasticProperties;
 }
@@ -137,17 +134,13 @@ QStringList RifElasticPropertiesReader::tokenize( const QString& line, const QSt
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RifElasticPropertiesReader::parseDouble( const QString& token,
-                                                const QString& propertyName,
-                                                int            lineNumber,
-                                                const QString& filePath )
+double RifElasticPropertiesReader::parseDouble( const QString& token, const QString& propertyName, int lineNumber, const QString& filePath )
 {
     bool   isOk  = false;
     double value = token.toDouble( &isOk );
     if ( !isOk )
     {
-        throw FileParseException(
-            QString( "Invalid number for '%1' on line %2: %3" ).arg( propertyName ).arg( lineNumber ).arg( filePath ) );
+        throw FileParseException( QString( "Invalid number for '%1' on line %2: %3" ).arg( propertyName ).arg( lineNumber ).arg( filePath ) );
     }
 
     return value;

ApplicationLibCode/FileInterface/RifElasticPropertiesReader.h

@@ -50,16 +50,11 @@ public:
                                        const QString&                     separator = "," );
 
 private:
-    static void readElasticProperties( std::vector<RifElasticProperties>& elasticProperties,
-                                       const QString&                     filePath,
-                                       const QString&                     separator );
-    static RifElasticProperties
-                       parseElasticProperties( const QString& line, int lineNumber, const QString& filePath, const QString& separator );
-    static QStringList tokenize( const QString& line, const QString& separator );
-    static void        verifyNonEmptyTokens( const QStringList& tokens,
-                                             const QStringList& nameOfNonEmptyTokens,
-                                             int                lineNumber,
-                                             const QString&     filePath );
+    static void readElasticProperties( std::vector<RifElasticProperties>& elasticProperties, const QString& filePath, const QString& separator );
+    static RifElasticProperties parseElasticProperties( const QString& line, int lineNumber, const QString& filePath, const QString& separator );
+    static QStringList          tokenize( const QString& line, const QString& separator );
+    static void
+        verifyNonEmptyTokens( const QStringList& tokens, const QStringList& nameOfNonEmptyTokens, int lineNumber, const QString& filePath );
 
     static double parseDouble( const QString& token, const QString& propertyName, int lineNumber, const QString& filePath );
 

ApplicationLibCode/FileInterface/RifElementPropertyReader.cpp

@@ -88,8 +88,7 @@ std::vector<std::string> RifElementPropertyReader::scalarElementFields() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::map<std::string, std::vector<float>>
-    RifElementPropertyReader::readAllElementPropertiesInFileContainingField( const std::string& fieldName )
+std::map<std::string, std::vector<float>> RifElementPropertyReader::readAllElementPropertiesInFileContainingField( const std::string& fieldName )
 {
     std::map<std::string, std::vector<float>> fieldAndData;
 

ApplicationLibCode/FileInterface/RifElementPropertyTableReader.cpp

@@ -128,8 +128,7 @@ void RifElementPropertyTableReader::readData( const RifElementPropertyMetadata*
                     {
                         if ( dataBlockFound )
                         {
-                            throw FileParseException(
-                                QString( "Number of columns mismatch at %1:%2" ).arg( metadata->fileName ).arg( lineNo ) );
+                            throw FileParseException( QString( "Number of columns mismatch at %1:%2" ).arg( metadata->fileName ).arg( lineNo ) );
                         }
                         collectedCols.clear();
                     }
@@ -151,8 +150,7 @@ void RifElementPropertyTableReader::readData( const RifElementPropertyMetadata*
                     }
                     else if ( collectedCols.size() > expectedColumnCount )
                     {
-                        throw FileParseException(
-                            QString( "Number of columns mismatch at %1:%2" ).arg( metadata->fileName ).arg( lineNo ) );
+                        throw FileParseException( QString( "Number of columns mismatch at %1:%2" ).arg( metadata->fileName ).arg( lineNo ) );
                     }
                     else
                     {
@@ -174,8 +172,7 @@ void RifElementPropertyTableReader::readData( const RifElementPropertyMetadata*
                         int elementId = parts.last().toInt( &parseOk );
                         if ( !parseOk )
                         {
-                            throw FileParseException(
-                                QString( "Parse failed at %1:%2" ).arg( metadata->fileName ).arg( lineNo ) );
+                            throw FileParseException( QString( "Parse failed at %1:%2" ).arg( metadata->fileName ).arg( lineNo ) );
                         }
                         table->elementIds.push_back( elementId );
                     }
@@ -184,8 +181,7 @@ void RifElementPropertyTableReader::readData( const RifElementPropertyMetadata*
                         float value = cols[c].toFloat( &parseOk );
                         if ( !parseOk )
                         {
-                            throw FileParseException(
-                                QString( "Parse failed at %1:%2" ).arg( metadata->fileName ).arg( lineNo ) );
+                            throw FileParseException( QString( "Parse failed at %1:%2" ).arg( metadata->fileName ).arg( lineNo ) );
                         }
                         table->data[c - 1].push_back( value );
                     }

ApplicationLibCode/FileInterface/RifElementPropertyTableReader.h

@@ -36,7 +36,7 @@ class RifElementPropertyTableReader : cvf::Object
 {
 public:
     static RifElementPropertyMetadata readMetadata( const QString& filePath );
-    static void readData( const RifElementPropertyMetadata* metadata, RifElementPropertyTable* table );
+    static void                       readData( const RifElementPropertyMetadata* metadata, RifElementPropertyTable* table );
 };
 
 //==================================================================================================

ApplicationLibCode/FileInterface/RifEnsembleFractureStatisticsExporter.cpp

@@ -32,12 +32,12 @@
 //--------------------------------------------------------------------------------------------------
 bool RifEnsembleFractureStatisticsExporter::writeAsStimPlanXml( const std::vector<std::shared_ptr<RigSlice2D>>& statistics,
                                                                 const std::vector<std::pair<QString, QString>>& properties,
-                                                                const QString&                             filePath,
-                                                                const std::vector<double>&                 gridXs,
-                                                                const std::vector<double>&                 gridYs,
-                                                                double                                     time,
-                                                                RiaDefines::EclipseUnitSystem              unitSystem,
-                                                                RigStimPlanFractureDefinition::Orientation orientation )
+                                                                const QString&                                  filePath,
+                                                                const std::vector<double>&                      gridXs,
+                                                                const std::vector<double>&                      gridYs,
+                                                                double                                          time,
+                                                                RiaDefines::EclipseUnitSystem                   unitSystem,
+                                                                RigStimPlanFractureDefinition::Orientation      orientation )
 {
     QFile data( filePath );
     if ( !data.open( QFile::WriteOnly | QFile::Truncate ) )
@@ -66,12 +66,11 @@ void RifEnsembleFractureStatisticsExporter::appendHeaderToStream( QTextStream& s
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifEnsembleFractureStatisticsExporter::appendPropertiesToStream(
-    QTextStream&                                    stream,
-    const std::vector<std::shared_ptr<RigSlice2D>>& statistics,
-    const std::vector<std::pair<QString, QString>>& properties,
-    const std::vector<double>&                      gridYs,
-    double                                          time )
+void RifEnsembleFractureStatisticsExporter::appendPropertiesToStream( QTextStream&                                    stream,
+                                                                      const std::vector<std::shared_ptr<RigSlice2D>>& statistics,
+                                                                      const std::vector<std::pair<QString, QString>>& properties,
+                                                                      const std::vector<double>&                      gridYs,
+                                                                      double                                          time )
 {
     CAF_ASSERT( statistics.size() == properties.size() );
 
@@ -109,7 +108,7 @@ void RifEnsembleFractureStatisticsExporter::appendPropertiesToStream(
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifEnsembleFractureStatisticsExporter::appendOrientationToStream( QTextStream& stream,
+void RifEnsembleFractureStatisticsExporter::appendOrientationToStream( QTextStream&                               stream,
                                                                        RigStimPlanFractureDefinition::Orientation orientation )
 {
     if ( orientation != RigStimPlanFractureDefinition::Orientation::UNDEFINED )

ApplicationLibCode/FileInterface/RifEnsembleStatisticsReader.cpp

@@ -31,11 +31,11 @@ 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, "" ) } );
+    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, "" ) } );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/FileInterface/RifEnsembleStatisticsReader.h

@@ -32,8 +32,8 @@ public:
     RifEnsembleStatisticsReader( RimEnsembleStatisticsCase* ensStatCase );
 
     std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool        values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
-    std::string unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
+    bool                values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::string         unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
 
     RiaDefines::EclipseUnitSystem unitSystem() const override;
 

ApplicationLibCode/FileInterface/RifFileParseTools.cpp

@@ -31,8 +31,7 @@
 //--------------------------------------------------------------------------------------------------
 QStringList RifFileParseTools::splitLineAndTrim( const QString& line, const QString& separator, bool skipEmptyParts )
 {
-    QStringList cols =
-        line.trimmed().split( separator, skipEmptyParts ? QString::SkipEmptyParts : QString::KeepEmptyParts );
+    QStringList cols = line.trimmed().split( separator, skipEmptyParts ? QString::SkipEmptyParts : QString::KeepEmptyParts );
     for ( QString& col : cols )
     {
         col = col.trimmed();

ApplicationLibCode/FileInterface/RifHdf5Reader.cpp

@@ -135,8 +135,7 @@ std::vector<QDateTime> RifHdf5Reader::timeSteps() const
 
             H5::H5File file( fileName.c_str(), H5F_ACC_RDONLY );
 
-            double timeStepValue = getDoubleAttribute( file,
-                                                       timeStepGroup,
+            double timeStepValue = getDoubleAttribute( file, timeStepGroup,
                                                        "timestep" ); // Assumes only one time step per file
             int    timeStepDays  = cvf::Math::floor( timeStepValue );
 

ApplicationLibCode/FileInterface/RifHdf5Reader.h

@@ -42,7 +42,7 @@ public:
 
     std::vector<QDateTime> timeSteps() const override;
     QStringList            propertyNames() const override;
-    bool dynamicResult( const QString& result, size_t stepIndex, std::vector<double>* values ) const override;
+    bool                   dynamicResult( const QString& result, size_t stepIndex, std::vector<double>* values ) const override;
 
 private:
     std::vector<std::string> getSourSimTimeStepFileNames( const QString& fileName ) const;
@@ -57,7 +57,7 @@ private:
 
     std::vector<std::string> getSubGroupNames( H5::H5File file, std::string baseGroupName ) const;
     std::vector<std::string> getResultNames( H5::H5File file, std::string baseGroupName ) const;
-    void getElementResultValues( H5::H5File file, std::string groupName, std::vector<double>* resultValues ) const;
+    void                     getElementResultValues( H5::H5File file, std::string groupName, std::vector<double>* resultValues ) const;
 
 private:
     QString                  m_fileName; // name of SourSimRL main file given by user

ApplicationLibCode/FileInterface/RifHdf5ReaderInterface.h

@@ -34,7 +34,7 @@ class RifHdf5ReaderInterface
 public:
     virtual ~RifHdf5ReaderInterface() = default;
 
-    virtual std::vector<QDateTime> timeSteps() const                                                         = 0;
-    virtual QStringList            propertyNames() const                                                     = 0;
-    virtual bool dynamicResult( const QString& result, size_t stepIndex, std::vector<double>* values ) const = 0;
+    virtual std::vector<QDateTime> timeSteps() const                                                                           = 0;
+    virtual QStringList            propertyNames() const                                                                       = 0;
+    virtual bool                   dynamicResult( const QString& result, size_t stepIndex, std::vector<double>* values ) const = 0;
 };

ApplicationLibCode/FileInterface/RifHdf5SummaryExporter.cpp

@@ -78,9 +78,7 @@ bool RifHdf5SummaryExporter::ensureHdf5FileIsCreatedMultithreaded( const std::ve
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifHdf5SummaryExporter::ensureHdf5FileIsCreated( const std::string& smspecFileName,
-                                                      const std::string& h5FileName,
-                                                      size_t&            hdfFilesCreatedCount )
+bool RifHdf5SummaryExporter::ensureHdf5FileIsCreated( const std::string& smspecFileName, const std::string& h5FileName, size_t& hdfFilesCreatedCount )
 {
     if ( !std::filesystem::exists( smspecFileName ) ) return false;
 
@@ -129,8 +127,7 @@ bool RifHdf5SummaryExporter::ensureHdf5FileIsCreated( const std::string& smspecF
         }
         catch ( std::exception& e )
         {
-            QString txt =
-                QString( "HDF export to file %1 failed : %3" ).arg( QString::fromStdString( smspecFileName ), e.what() );
+            QString txt = QString( "HDF export to file %1 failed : %3" ).arg( QString::fromStdString( smspecFileName ), e.what() );
 
             RiaLogging::error( txt );
 
@@ -206,8 +203,7 @@ bool RifHdf5SummaryExporter::writeSummaryVectors( RifHdf5Exporter& exporter, Opm
     const std::string datasetName( "values" );
 
     std::map<std::string, std::vector<RifEclipseSummaryAddress>> mapVectorNameToSummaryAddresses;
-    auto [addresses, addressToKeywordMap] =
-        RifOpmCommonSummaryTools::buildAddressesAndKeywordMap( sourceSummaryData.keywordList() );
+    auto [addresses, addressToKeywordMap] = RifOpmCommonSummaryTools::buildAddressesAndKeywordMap( sourceSummaryData.keywordList() );
     for ( const auto& adr : addresses )
     {
         auto vectorName = adr.vectorName();
@@ -240,8 +236,8 @@ bool RifHdf5SummaryExporter::writeSummaryVectors( RifHdf5Exporter& exporter, Opm
 
             try
             {
-                const std::vector<float>& values = sourceSummaryData.get( keyword );
-                auto dataValuesGroup = exporter.createGroup( &keywordGroup, smspecKeywordText.toStdString() );
+                const std::vector<float>& values          = sourceSummaryData.get( keyword );
+                auto                      dataValuesGroup = exporter.createGroup( &keywordGroup, smspecKeywordText.toStdString() );
 
                 exporter.writeDataset( dataValuesGroup, datasetName, values );
                 dataValuesGroup.close();

ApplicationLibCode/FileInterface/RifHdf5SummaryExporter.h

@@ -44,9 +44,7 @@ public:
                                                       const std::vector<std::string>& h5FileNames,
                                                       int                             threadCount );
 
-    static bool ensureHdf5FileIsCreated( const std::string& smspecFileName,
-                                         const std::string& h5FileName,
-                                         size_t&            hdfFilesCreatedCount );
+    static bool ensureHdf5FileIsCreated( const std::string& smspecFileName, const std::string& h5FileName, size_t& hdfFilesCreatedCount );
 
 private:
     static bool writeGeneralSection( RifHdf5Exporter& exporter, Opm::EclIO::ESmry& sourceSummaryData );

ApplicationLibCode/FileInterface/RifInputPropertyLoader.cpp

@@ -88,8 +88,7 @@ void RifInputPropertyLoader::loadAndSynchronizeInputProperties( RimEclipseInputP
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::map<QString, QString> RifInputPropertyLoader::readProperties( const QString&      fileName,
-                                                                   RigEclipseCaseData* eclipseCaseData )
+std::map<QString, QString> RifInputPropertyLoader::readProperties( const QString& fileName, RigEclipseCaseData* eclipseCaseData )
 {
     RiaDefines::ImportFileType fileType = RiaDefines::obtainFileTypeFromFileName( fileName );
     if ( fileType == RiaDefines::ImportFileType::ROFF_FILE )

ApplicationLibCode/FileInterface/RifMultipleSummaryReaders.h

@@ -35,9 +35,9 @@ public:
     void addReader( RifSummaryReaderInterface* reader );
     void removeReader( RifSummaryReaderInterface* reader );
 
-    std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool        values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
-    std::string unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
+    std::vector<time_t>           timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
+    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::string                   unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem unitSystem() const override;
 
     void rebuildMetaData();

ApplicationLibCode/FileInterface/RifOpmCommonSummary.cpp

@@ -99,10 +99,8 @@ bool RifOpmCommonEclipseSummary::open( const QString& fileName, bool includeRest
             const QString smspecFileNameShort = QFileInfo( smspecFileName ).fileName();
             const QString esmryFileNameShort  = QFileInfo( candidateEsmryFileName ).fileName();
 
-            RiaLogging::debug( QString( " %3 : %1 is older than %2, recreating %1." )
-                                   .arg( esmryFileNameShort )
-                                   .arg( smspecFileNameShort )
-                                   .arg( root ) );
+            RiaLogging::debug(
+                QString( " %3 : %1 is older than %2, recreating %1." ).arg( esmryFileNameShort ).arg( smspecFileNameShort ).arg( root ) );
 
             std::filesystem::remove( candidateEsmryFileName.toStdString() );
         }
@@ -111,8 +109,7 @@ bool RifOpmCommonEclipseSummary::open( const QString& fileName, bool includeRest
         {
             try
             {
-                auto temporarySummaryFile =
-                    std::make_unique<Opm::EclIO::ESmry>( smspecFileName.toStdString(), includeRestartFiles );
+                auto temporarySummaryFile = std::make_unique<Opm::EclIO::ESmry>( smspecFileName.toStdString(), includeRestartFiles );
 
                 temporarySummaryFile->make_esmry_file();
 
@@ -243,9 +240,7 @@ void RifOpmCommonEclipseSummary::buildMetaData()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifOpmCommonEclipseSummary::openFileReader( const QString&       fileName,
-                                                 bool                 includeRestartFiles,
-                                                 RiaThreadSafeLogger* threadSafeLogger )
+bool RifOpmCommonEclipseSummary::openFileReader( const QString& fileName, bool includeRestartFiles, RiaThreadSafeLogger* threadSafeLogger )
 {
     // Make sure to check the SMSPEC file name, as it is supported to import ESMRY files without any SMSPEC data.
     auto smspecFileName = smspecSummaryFilename( fileName );
@@ -265,8 +260,7 @@ bool RifOpmCommonEclipseSummary::openFileReader( const QString&       fileName,
                     // No SMSPEC file present, OK to import ESMRY file
                     isValidEsmryFile = true;
                 }
-                else if ( RiaFilePathTools::isFirstOlderThanSecond( smspecFileName.toStdString(),
-                                                                    candidateEsmryFileName.toStdString() ) )
+                else if ( RiaFilePathTools::isFirstOlderThanSecond( smspecFileName.toStdString(), candidateEsmryFileName.toStdString() ) )
                 {
                     isValidEsmryFile = true;
                 }
@@ -285,8 +279,7 @@ bool RifOpmCommonEclipseSummary::openFileReader( const QString&       fileName,
 
                 if ( isValidEsmryFile )
                 {
-                    m_enhancedReader = std::make_unique<Opm::EclIO::ExtESmry>( candidateEsmryFileName.toStdString(),
-                                                                               includeRestartFiles );
+                    m_enhancedReader = std::make_unique<Opm::EclIO::ExtESmry>( candidateEsmryFileName.toStdString(), includeRestartFiles );
 
                     return true;
                 }

ApplicationLibCode/FileInterface/RifOpmCommonSummary.h

@@ -47,9 +47,7 @@ class RiaThreadSafeLogger;
 class RifOpmCommonSummaryTools
 {
 public:
-    static std::tuple<std::set<RifEclipseSummaryAddress>,
-                      std::map<RifEclipseSummaryAddress, size_t>,
-                      std::map<RifEclipseSummaryAddress, std::string>>
+    static std::tuple<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, size_t>, std::map<RifEclipseSummaryAddress, std::string>>
         buildAddressesSmspecAndKeywordMap( const Opm::EclIO::ESmry* summaryFile );
 
     static std::pair<std::set<RifEclipseSummaryAddress>, std::map<RifEclipseSummaryAddress, std::string>>
@@ -74,9 +72,9 @@ public:
 
     bool open( const QString& fileName, bool includeRestartFiles, RiaThreadSafeLogger* threadSafeLogger );
 
-    std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool        values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
-    std::string unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
+    std::vector<time_t>           timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
+    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::string                   unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem unitSystem() const override;
 
 private:

ApplicationLibCode/FileInterface/RifOpmGridTools.cpp

@@ -93,8 +93,8 @@ void RifOpmGridTools::importCoordinatesForRadialGrid( const std::string& gridFil
     }
     catch ( ... )
     {
-        RiaLogging::warning( QString( "Failed to open grid case for import of radial coordinates : %1" )
-                                 .arg( QString::fromStdString( gridFilePath ) ) );
+        RiaLogging::warning(
+            QString( "Failed to open grid case for import of radial coordinates : %1" ).arg( QString::fromStdString( gridFilePath ) ) );
     }
 }
 
@@ -129,10 +129,7 @@ void RifOpmGridTools::importCoordinatesForRadialGrid( const std::string& gridFil
 // 3. Find the closest point on this pillar, and use this point as the adjusted coordinate for the node
 //
 //--------------------------------------------------------------------------------------------------
-void RifOpmGridTools::transferCoordinates( Opm::EclIO::EGrid& opmMainGrid,
-                                           Opm::EclIO::EGrid& opmGrid,
-                                           RigMainGrid*       riMainGrid,
-                                           RigGridBase*       riGrid )
+void RifOpmGridTools::transferCoordinates( Opm::EclIO::EGrid& opmMainGrid, Opm::EclIO::EGrid& opmGrid, RigMainGrid* riMainGrid, RigGridBase* riGrid )
 {
     size_t cellCount = opmGrid.totalNumberOfCells();
     if ( cellCount != riGrid->cellCount() ) return;
@@ -141,8 +138,7 @@ void RifOpmGridTools::transferCoordinates( Opm::EclIO::EGrid& opmMainGrid,
     // Prefix OPM structures with _opm_and ResInsight structures with _ri_
 
     // Compute the center of the LGR radial grid cells for each K layer
-    std::map<int, std::pair<double, double>> radialGridCenterTopLayerOpm =
-        computeXyCenterForTopOfCells( opmMainGrid, opmGrid, riGrid );
+    std::map<int, std::pair<double, double>> radialGridCenterTopLayerOpm = computeXyCenterForTopOfCells( opmMainGrid, opmGrid, riGrid );
 
     std::array<double, 8> opmX{};
     std::array<double, 8> opmY{};
@@ -258,9 +254,8 @@ void RifOpmGridTools::transferCoordinates( Opm::EclIO::EGrid& opmMainGrid,
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::map<int, std::pair<double, double>> RifOpmGridTools::computeXyCenterForTopOfCells( Opm::EclIO::EGrid& opmMainGrid,
-                                                                                        Opm::EclIO::EGrid& opmGrid,
-                                                                                        RigGridBase*       riGrid )
+std::map<int, std::pair<double, double>>
+    RifOpmGridTools::computeXyCenterForTopOfCells( Opm::EclIO::EGrid& opmMainGrid, Opm::EclIO::EGrid& opmGrid, RigGridBase* riGrid )
 {
     if ( !riGrid || riGrid->isMainGrid() ) return {};
 
@@ -319,10 +314,8 @@ std::map<int, std::pair<double, double>> RifOpmGridTools::computeXyCenterForTopO
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<std::vector<cvf::Vec3d>> RifOpmGridTools::computeSnapToCoordinates( Opm::EclIO::EGrid& opmMainGrid,
-                                                                                Opm::EclIO::EGrid& opmGrid,
-                                                                                int                mainGridCellIndex,
-                                                                                int                lgrCellIndex )
+std::vector<std::vector<cvf::Vec3d>>
+    RifOpmGridTools::computeSnapToCoordinates( Opm::EclIO::EGrid& opmMainGrid, Opm::EclIO::EGrid& opmGrid, int mainGridCellIndex, int lgrCellIndex )
 {
     auto hostCellIndices = opmGrid.hostCellsGlobalIndex();
     auto lgrIjk          = opmGrid.ijk_from_global_index( lgrCellIndex );

ApplicationLibCode/FileInterface/RifOpmGridTools.h

@@ -45,16 +45,11 @@ public:
     static void importCoordinatesForRadialGrid( const std::string& gridFilePath, RigMainGrid* mainGrid );
 
 private:
-    static void transferCoordinates( Opm::EclIO::EGrid& opmMainGrid,
-                                     Opm::EclIO::EGrid& opmGrid,
-                                     RigMainGrid*       riMainGrid,
-                                     RigGridBase*       riGrid );
+    static void transferCoordinates( Opm::EclIO::EGrid& opmMainGrid, Opm::EclIO::EGrid& opmGrid, RigMainGrid* riMainGrid, RigGridBase* riGrid );
 
     static std::map<int, std::pair<double, double>>
         computeXyCenterForTopOfCells( Opm::EclIO::EGrid& opmMainGrid, Opm::EclIO::EGrid& opmGrid, RigGridBase* riGrid );
 
-    static std::vector<std::vector<cvf::Vec3d>> computeSnapToCoordinates( Opm::EclIO::EGrid& opmMainGrid,
-                                                                          Opm::EclIO::EGrid& opmGrid,
-                                                                          int                mainGridCellIndex,
-                                                                          int                lgrCellIndex );
+    static std::vector<std::vector<cvf::Vec3d>>
+        computeSnapToCoordinates( Opm::EclIO::EGrid& opmMainGrid, Opm::EclIO::EGrid& opmGrid, int mainGridCellIndex, int lgrCellIndex );
 };

ApplicationLibCode/FileInterface/RifOpmHdf5Summary.cpp

@@ -167,11 +167,10 @@ void RifOpmHdf5Summary::buildMetaData()
         }
 
         {
-            auto [addresses, smspecIndices, addressToKeywordMap] =
-                RifOpmCommonSummaryTools::buildAddressesSmspecAndKeywordMap( m_eSmry.get() );
-            m_allResultAddresses         = addresses;
-            m_adrToSmspecIndices         = smspecIndices;
-            m_summaryAddressToKeywordMap = addressToKeywordMap;
+            auto [addresses, smspecIndices, addressToKeywordMap] = RifOpmCommonSummaryTools::buildAddressesSmspecAndKeywordMap( m_eSmry.get() );
+            m_allResultAddresses                                 = addresses;
+            m_adrToSmspecIndices                                 = smspecIndices;
+            m_summaryAddressToKeywordMap                         = addressToKeywordMap;
         }
     }
 }
@@ -179,9 +178,7 @@ void RifOpmHdf5Summary::buildMetaData()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifOpmHdf5Summary::openESmryFile( const QString&       headerFileName,
-                                       bool                 includeRestartFiles,
-                                       RiaThreadSafeLogger* threadSafeLogger )
+bool RifOpmHdf5Summary::openESmryFile( const QString& headerFileName, bool includeRestartFiles, RiaThreadSafeLogger* threadSafeLogger )
 {
     try
     {

ApplicationLibCode/FileInterface/RifOpmHdf5Summary.h

@@ -56,9 +56,9 @@ public:
 
     bool open( const QString& headerFileName, bool includeRestartFiles, RiaThreadSafeLogger* threadSafeLogger );
 
-    std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool        values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
-    std::string unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
+    std::vector<time_t>           timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
+    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::string                   unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem unitSystem() const override;
 
 private:

ApplicationLibCode/FileInterface/RifParameterXmlReader.cpp

@@ -169,8 +169,7 @@ bool RifParameterXmlReader::parseFile( QString& outErrorText )
 
                     if ( xml.attributes().hasAttribute( "advanced" ) )
                     {
-                        if ( xml.attributes().value( "advanced" ).toString().toLower() == "true" )
-                            parameter->setAdvanced( true );
+                        if ( xml.attributes().value( "advanced" ).toString().toLower() == "true" ) parameter->setAdvanced( true );
                     }
 
                     if ( xml.attributes().hasAttribute( "description" ) )

ApplicationLibCode/FileInterface/RifPerforationIntervalReader.cpp

@@ -28,8 +28,7 @@ const QString PERFORATION_KEY( "perforation" );
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::map<QString, std::vector<RifPerforationInterval>>
-    RifPerforationIntervalReader::readPerforationIntervals( const QStringList& filePaths )
+std::map<QString, std::vector<RifPerforationInterval>> RifPerforationIntervalReader::readPerforationIntervals( const QStringList& filePaths )
 {
     std::map<QString, std::vector<RifPerforationInterval>> perforationIntervals;
 
@@ -44,8 +43,7 @@ std::map<QString, std::vector<RifPerforationInterval>>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::map<QString, std::vector<RifPerforationInterval>>
-    RifPerforationIntervalReader::readPerforationIntervals( const QString& filePath )
+std::map<QString, std::vector<RifPerforationInterval>> RifPerforationIntervalReader::readPerforationIntervals( const QString& filePath )
 {
     std::map<QString, std::vector<RifPerforationInterval>> perforationIntervals;
 
@@ -99,8 +97,7 @@ void RifPerforationIntervalReader::readFileIntoMap( const QString&
 
             if ( parts[3] == PERFORATION_KEY )
             {
-                interval.date = QDate::fromString( QString( "%1 %2 %3" ).arg( parts[0] ).arg( parts[1] ).arg( parts[2] ),
-                                                   "dd MMM yyyy" );
+                interval.date = QDate::fromString( QString( "%1 %2 %3" ).arg( parts[0] ).arg( parts[1] ).arg( parts[2] ), "dd MMM yyyy" );
                 interval.startOfHistory = false;
 
                 mdStartIndex = 4;

ApplicationLibCode/FileInterface/RifPerforationIntervalReader.h

@@ -44,6 +44,5 @@ public:
     static std::map<QString, std::vector<RifPerforationInterval>> readPerforationIntervals( const QString& filePath );
 
 private:
-    static void readFileIntoMap( const QString&                                          filePath,
-                                 std::map<QString, std::vector<RifPerforationInterval>>* perforations );
+    static void readFileIntoMap( const QString& filePath, std::map<QString, std::vector<RifPerforationInterval>>* perforations );
 };

ApplicationLibCode/FileInterface/RifProjectSummaryDataWriter.h

@@ -40,9 +40,7 @@ public:
     void importFromProjectSummaryFile( const std::string& projectSummaryFileName );
 
     // Set data for a list of keyword/unit/values. If a keyword exist, the data will be overwritten
-    void setData( const std::vector<std::string>&        keywords,
-                  const std::vector<std::string>&        units,
-                  const std::vector<std::vector<float>>& values );
+    void setData( const std::vector<std::string>& keywords, const std::vector<std::string>& units, const std::vector<std::vector<float>>& values );
 
     void writeDataToFile( const std::string& fileName );
 

ApplicationLibCode/FileInterface/RifReaderEclipseInput.h

@@ -38,10 +38,7 @@ public:
     {
         return false;
     }
-    bool dynamicResult( const QString&                result,
-                        RiaDefines::PorosityModelType matrixOrFracture,
-                        size_t                        stepIndex,
-                        std::vector<double>*          values ) override
+    bool dynamicResult( const QString& result, RiaDefines::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values ) override
     {
         return false;
     }

ApplicationLibCode/FileInterface/RifReaderEclipseOutput.cpp

@@ -151,15 +151,13 @@ bool transferGridCellData( RigMainGrid*         mainGrid,
         int matrixActiveIndex = ecl_grid_get_active_index1( localEclGrid, gridLocalCellIndex );
         if ( matrixActiveIndex != -1 )
         {
-            activeCellInfo->setCellResultIndex( cellStartIndex + gridLocalCellIndex,
-                                                matrixActiveStartIndex + matrixActiveIndex );
+            activeCellInfo->setCellResultIndex( cellStartIndex + gridLocalCellIndex, matrixActiveStartIndex + matrixActiveIndex );
         }
 
         int fractureActiveIndex = ecl_grid_get_active_fracture_index1( localEclGrid, gridLocalCellIndex );
         if ( fractureActiveIndex != -1 )
         {
-            fractureActiveCellInfo->setCellResultIndex( cellStartIndex + gridLocalCellIndex,
-                                                        fractureActiveStartIndex + fractureActiveIndex );
+            fractureActiveCellInfo->setCellResultIndex( cellStartIndex + gridLocalCellIndex, fractureActiveStartIndex + fractureActiveIndex );
         }
 
         // Parent cell index
@@ -178,8 +176,7 @@ bool transferGridCellData( RigMainGrid*         mainGrid,
         int cIdx;
         for ( cIdx = 0; cIdx < 8; ++cIdx )
         {
-            double* point =
-                mainGrid->nodes()[nodeStartIndex + (size_t)gridLocalCellIndex * 8 + cellMappingECLRi[cIdx]].ptr();
+            double* point = mainGrid->nodes()[nodeStartIndex + (size_t)gridLocalCellIndex * 8 + cellMappingECLRi[cIdx]].ptr();
             ecl_grid_get_cell_corner_xyz1( localEclGrid, gridLocalCellIndex, cIdx, &( point[0] ), &( point[1] ), &( point[2] ) );
             point[2]                   = -point[2]; // Flipping Z making depth become negative z values
             cell.cornerIndices()[cIdx] = nodeStartIndex + (size_t)gridLocalCellIndex * 8 + cIdx;
@@ -254,9 +251,8 @@ bool RifReaderEclipseOutput::transferGeometry( const ecl_grid_type* mainEclGrid,
         return false;
     }
 
-    RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
-    RigActiveCellInfo* fractureActiveCellInfo =
-        eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
+    RigActiveCellInfo* activeCellInfo         = eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
+    RigActiveCellInfo* fractureActiveCellInfo = eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
 
     CVF_ASSERT( activeCellInfo && fractureActiveCellInfo );
 
@@ -338,13 +334,7 @@ bool RifReaderEclipseOutput::transferGeometry( const ecl_grid_type* mainEclGrid,
         ecl_grid_type* localEclGrid = ecl_grid_iget_lgr( mainEclGrid, lgrIdx );
         RigLocalGrid*  localGrid    = static_cast<RigLocalGrid*>( mainGrid->gridByIndex( lgrIdx + 1 ) );
 
-        transferGridCellData( mainGrid,
-                              activeCellInfo,
-                              fractureActiveCellInfo,
-                              localGrid,
-                              localEclGrid,
-                              globalMatrixActiveSize,
-                              globalFractureActiveSize );
+        transferGridCellData( mainGrid, activeCellInfo, fractureActiveCellInfo, localGrid, localEclGrid, globalMatrixActiveSize, globalFractureActiveSize );
 
         int matrixActiveCellCount = ecl_grid_get_nactive( localEclGrid );
         globalMatrixActiveSize += matrixActiveCellCount;
@@ -375,10 +365,9 @@ bool RifReaderEclipseOutput::open( const QString& fileName, RigEclipseCaseData*
 
     if ( !RifEclipseOutputFileTools::isValidEclipseFileName( fileName ) )
     {
-        QString errorMessage =
-            QFileInfo( fileName ).fileName() +
-            QString( " is not a valid Eclipse file name.\n"
-                     "Please make sure the file does not contain a mix of upper and lower case letters." );
+        QString errorMessage = QFileInfo( fileName ).fileName() +
+                               QString( " is not a valid Eclipse file name.\n"
+                                        "Please make sure the file does not contain a mix of upper and lower case letters." );
         RiaLogging::error( errorMessage );
         return false;
     }
@@ -459,8 +448,7 @@ bool RifReaderEclipseOutput::open( const QString& fileName, RigEclipseCaseData*
                 transferDynamicNNCData( mainEclGrid, mainGrid );
             }
 
-            RigActiveCellInfo* activeCellInfo =
-                m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
+            RigActiveCellInfo* activeCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
 
             bool includeInactiveCells = includeInactiveCellsInFaultGeometry();
             mainGrid->nncData()->setSourceDataForProcessing( mainGrid, activeCellInfo, includeInactiveCells );
@@ -534,9 +522,8 @@ void RifReaderEclipseOutput::setHdf5FileName( const QString& fileName )
     {
         if ( allTimeSteps().size() != sourSimTimeSteps.size() )
         {
-            RiaLogging::error( QString( "HDF: Time step count mismatch, Eclipse : %1 ; HDF : %2 " )
-                                   .arg( allTimeSteps().size() )
-                                   .arg( sourSimTimeSteps.size() ) );
+            RiaLogging::error(
+                QString( "HDF: Time step count mismatch, Eclipse : %1 ; HDF : %2 " ).arg( allTimeSteps().size() ).arg( sourSimTimeSteps.size() ) );
 
             return;
         }
@@ -554,9 +541,8 @@ void RifReaderEclipseOutput::setHdf5FileName( const QString& fileName )
             }
             else
             {
-                RiaLogging::error( QString( "HDF: Time step count mismatch, Eclipse : %1 ; HDF : %2 " )
-                                       .arg( timeStepInfos.size() )
-                                       .arg( sourSimTimeSteps.size() ) );
+                RiaLogging::error(
+                    QString( "HDF: Time step count mismatch, Eclipse : %1 ; HDF : %2 " ).arg( timeStepInfos.size() ).arg( sourSimTimeSteps.size() ) );
 
                 // We have less soursim time steps than eclipse time steps
                 isTimeStampsEqual = false;
@@ -590,8 +576,7 @@ void RifReaderEclipseOutput::setHdf5FileName( const QString& fileName )
             }
         }
 
-        timeStepInfos =
-            RigEclipseTimeStepInfo::createTimeStepInfos( sourSimTimeSteps, reportNumbers, daysSinceSimulationStart );
+        timeStepInfos = RigEclipseTimeStepInfo::createTimeStepInfos( sourSimTimeSteps, reportNumbers, daysSinceSimulationStart );
     }
 
     QStringList resultNames = hdf5ReaderInterface->propertyNames();
@@ -643,10 +628,7 @@ void RifReaderEclipseOutput::importFaults( const QStringList& fileSet, cvf::Coll
             if ( fname.endsWith( ".DATA" ) )
             {
                 std::vector<QString> filenamesWithFaults;
-                RifEclipseInputFileTools::readFaultsInGridSection( fname,
-                                                                   faults,
-                                                                   &filenamesWithFaults,
-                                                                   faultIncludeFileAbsolutePathPrefix() );
+                RifEclipseInputFileTools::readFaultsInGridSection( fname, faults, &filenamesWithFaults, faultIncludeFileAbsolutePathPrefix() );
 
                 std::sort( filenamesWithFaults.begin(), filenamesWithFaults.end() );
                 std::vector<QString>::iterator last = std::unique( filenamesWithFaults.begin(), filenamesWithFaults.end() );
@@ -700,9 +682,7 @@ void RifReaderEclipseOutput::importEquilData( const QString&      deckFileName,
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifReaderEclipseOutput::transferStaticNNCData( const ecl_grid_type* mainEclGrid,
-                                                    ecl_file_type*       init_file,
-                                                    RigMainGrid*         mainGrid )
+void RifReaderEclipseOutput::transferStaticNNCData( const ecl_grid_type* mainEclGrid, ecl_file_type* init_file, RigMainGrid* mainGrid )
 {
     if ( !m_ecl_init_file ) return;
 
@@ -712,8 +692,7 @@ void RifReaderEclipseOutput::transferStaticNNCData( const ecl_grid_type* mainEcl
     ecl_nnc_geometry_type* nnc_geo = ecl_nnc_geometry_alloc( mainEclGrid );
     if ( nnc_geo )
     {
-        ecl_nnc_data_type* tran_data =
-            ecl_nnc_data_alloc_tran( mainEclGrid, nnc_geo, ecl_file_get_global_view( init_file ) );
+        ecl_nnc_data_type* tran_data = ecl_nnc_data_alloc_tran( mainEclGrid, nnc_geo, ecl_file_get_global_view( init_file ) );
         if ( tran_data )
         {
             int numNNC       = ecl_nnc_data_get_size( tran_data );
@@ -743,8 +722,7 @@ void RifReaderEclipseOutput::transferStaticNNCData( const ecl_grid_type* mainEcl
                 }
 
                 mainGrid->nncData()->setEclipseConnections( nncConnections );
-                mainGrid->nncData()->makeScalarResultAndSetValues( RiaDefines::propertyNameCombTrans(),
-                                                                   transmissibilityValuesTemp );
+                mainGrid->nncData()->makeScalarResultAndSetValues( RiaDefines::propertyNameCombTrans(), transmissibilityValuesTemp );
             }
 
             ecl_nnc_data_free( tran_data );
@@ -774,11 +752,7 @@ void RifReaderEclipseOutput::transferDynamicNNCData( const ecl_grid_type* mainEc
 
     for ( size_t timeStep = 0; timeStep < timeStepCount; ++timeStep )
     {
-        m_dynamicResultsAccess->dynamicNNCResults( mainEclGrid,
-                                                   timeStep,
-                                                   &waterFluxData[timeStep],
-                                                   &oilFluxData[timeStep],
-                                                   &gasFluxData[timeStep] );
+        m_dynamicResultsAccess->dynamicNNCResults( mainEclGrid, timeStep, &waterFluxData[timeStep], &oilFluxData[timeStep], &gasFluxData[timeStep] );
     }
 }
 
@@ -836,14 +810,12 @@ bool RifReaderEclipseOutput::readActiveCellInfo()
         QString initFileName = RifEclipseOutputFileTools::firstFileNameOfType( m_filesWithSameBaseName, ECL_INIT_FILE );
         if ( initFileName.size() > 0 )
         {
-            ecl_file_type* ecl_file =
-                ecl_file_open( RiaStringEncodingTools::toNativeEncoded( initFileName ).data(), ECL_FILE_CLOSE_STREAM );
+            ecl_file_type* ecl_file = ecl_file_open( RiaStringEncodingTools::toNativeEncoded( initFileName ).data(), ECL_FILE_CLOSE_STREAM );
             if ( ecl_file )
             {
                 bool isDualPorosity    = m_eclipseCase->mainGrid()->isDualPorosity();
                 int  cellCountMainGrid = static_cast<int>( m_eclipseCase->mainGrid()->cellCount() );
-                actnumValuesPerGrid =
-                    RifActiveCellsReader::activeCellsFromPorvKeyword( ecl_file, isDualPorosity, cellCountMainGrid );
+                actnumValuesPerGrid    = RifActiveCellsReader::activeCellsFromPorvKeyword( ecl_file, isDualPorosity, cellCountMainGrid );
                 ecl_file_close( ecl_file );
             }
         }
@@ -855,8 +827,7 @@ bool RifReaderEclipseOutput::readActiveCellInfo()
         QString egridFileName = RifEclipseOutputFileTools::firstFileNameOfType( m_filesWithSameBaseName, ECL_EGRID_FILE );
         if ( egridFileName.size() > 0 )
         {
-            ecl_file_type* ecl_file =
-                ecl_file_open( RiaStringEncodingTools::toNativeEncoded( egridFileName ).data(), ECL_FILE_CLOSE_STREAM );
+            ecl_file_type* ecl_file = ecl_file_open( RiaStringEncodingTools::toNativeEncoded( egridFileName ).data(), ECL_FILE_CLOSE_STREAM );
             if ( ecl_file )
             {
                 actnumValuesPerGrid = RifActiveCellsReader::activeCellsFromActnumKeyword( ecl_file );
@@ -877,9 +848,8 @@ bool RifReaderEclipseOutput::readActiveCellInfo()
         return false;
     }
 
-    RigActiveCellInfo* activeCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
-    RigActiveCellInfo* fractureActiveCellInfo =
-        m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
+    RigActiveCellInfo* activeCellInfo         = m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
+    RigActiveCellInfo* fractureActiveCellInfo = m_eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
 
     activeCellInfo->setReservoirCellCount( reservoirCellCount );
     fractureActiveCellInfo->setReservoirCellCount( reservoirCellCount );
@@ -936,7 +906,7 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
 
     progInfo.setNextProgressIncrement( m_filesWithSameBaseName.size() );
 
-    RigCaseCellResultsData* matrixModelResults = m_eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
+    RigCaseCellResultsData* matrixModelResults   = m_eclipseCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL );
     RigCaseCellResultsData* fractureModelResults = m_eclipseCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL );
 
     std::vector<RigEclipseTimeStepInfo> timeStepInfos;
@@ -1036,9 +1006,7 @@ void RifReaderEclipseOutput::buildMetaData( ecl_grid_type* grid )
         std::vector<ecl_file_type*> filesUsedToFindAvailableKeywords;
         filesUsedToFindAvailableKeywords.push_back( m_ecl_init_file );
 
-        RifEclipseOutputFileTools::findKeywordsAndItemCount( filesUsedToFindAvailableKeywords,
-                                                             &resultNames,
-                                                             &resultNamesDataItemCounts );
+        RifEclipseOutputFileTools::findKeywordsAndItemCount( filesUsedToFindAvailableKeywords, &resultNames, &resultNamesDataItemCounts );
 
         std::vector<RigEclipseTimeStepInfo> staticTimeStepInfo;
         if ( !timeStepInfos.empty() )
@@ -1101,9 +1069,7 @@ void RifReaderEclipseOutput::ensureDynamicResultAccessIsPresent()
 //--------------------------------------------------------------------------------------------------
 /// Get all values of a given static result as doubles
 //--------------------------------------------------------------------------------------------------
-bool RifReaderEclipseOutput::staticResult( const QString&                result,
-                                           RiaDefines::PorosityModelType matrixOrFracture,
-                                           std::vector<double>*          values )
+bool RifReaderEclipseOutput::staticResult( const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values )
 {
     CVF_ASSERT( values );
 
@@ -1240,9 +1206,7 @@ struct SegmentPositionContribution
     bool       m_isFromAbove;
 };
 
-size_t localGridCellIndexFromErtConnection( const RigGridBase*    grid,
-                                            const well_conn_type* ert_connection,
-                                            const char*           wellNameForErrorMsgs )
+size_t localGridCellIndexFromErtConnection( const RigGridBase* grid, const well_conn_type* ert_connection, const char* wellNameForErrorMsgs )
 {
     CVF_ASSERT( ert_connection );
     CVF_ASSERT( grid );
@@ -1292,8 +1256,8 @@ size_t localGridCellIndexFromErtConnection( const RigGridBase*    grid,
         if ( wellNameForErrorMsgs )
         {
             cvf::Trace::show( "Well Connection for grid " + cvf::String( grid->gridName() ) +
-                              "\n - Ignored connection with invalid K value (K=" + cvf::String( cellK ) + ", max K = " +
-                              cvf::String( maxCellK ) + ") for well : " + cvf::String( wellNameForErrorMsgs ) );
+                              "\n - Ignored connection with invalid K value (K=" + cvf::String( cellK ) +
+                              ", max K = " + cvf::String( maxCellK ) + ") for well : " + cvf::String( wellNameForErrorMsgs ) );
         }
         return cvf::UNDEFINED_SIZE_T;
     }
@@ -1337,8 +1301,7 @@ RigWellResultPoint RifReaderEclipseOutput::createWellResultPoint( const RigGridB
         resultPoint.m_oilRate      = oilRate;
         resultPoint.m_waterRate    = waterRate;
 
-        resultPoint.m_gasRate =
-            RiaEclipseUnitTools::convertSurfaceGasFlowRateToOilEquivalents( m_eclipseCase->unitsType(), gasRate );
+        resultPoint.m_gasRate = RiaEclipseUnitTools::convertSurfaceGasFlowRateToOilEquivalents( m_eclipseCase->unitsType(), gasRate );
 
         resultPoint.m_connectionFactor = connectionFactor;
     }
@@ -1501,14 +1464,12 @@ public:
             const well_conn_type* ert_wellhead = well_state_iget_wellhead( ert_well_state, static_cast<int>( gridNr ) );
             if ( ert_wellhead )
             {
-                size_t localGridCellidx =
-                    localGridCellIndexFromErtConnection( m_mainGrid->gridByIndex( gridNr ), ert_wellhead, nullptr );
+                size_t localGridCellidx = localGridCellIndexFromErtConnection( m_mainGrid->gridByIndex( gridNr ), ert_wellhead, nullptr );
                 this->insertTheParentCells( gridNr, localGridCellidx );
             }
 
-            std::string gridname = gridNr == 0 ? ECL_GRID_GLOBAL_GRID : m_mainGrid->gridByIndex( gridNr )->gridName();
-            const well_conn_collection_type* connections =
-                well_state_get_grid_connections( ert_well_state, gridname.data() );
+            std::string                      gridname = gridNr == 0 ? ECL_GRID_GLOBAL_GRID : m_mainGrid->gridByIndex( gridNr )->gridName();
+            const well_conn_collection_type* connections = well_state_get_grid_connections( ert_well_state, gridname.data() );
 
             if ( connections )
             {
@@ -1519,9 +1480,8 @@ public:
                     {
                         well_conn_type* ert_connection = well_conn_collection_iget( connections, connIdx );
 
-                        size_t localGridCellidx = localGridCellIndexFromErtConnection( m_mainGrid->gridByIndex( gridNr ),
-                                                                                       ert_connection,
-                                                                                       nullptr );
+                        size_t localGridCellidx =
+                            localGridCellIndexFromErtConnection( m_mainGrid->gridByIndex( gridNr ), ert_connection, nullptr );
                         this->insertTheParentCells( gridNr, localGridCellidx );
                     }
                 }
@@ -1564,8 +1524,7 @@ private:
             gridIndex             = lgrHost->parentGrid()->gridIndex();
             gridCellIndex         = connectionCell.parentCellIndex();
 
-            size_t parentReservoirCellIdx =
-                m_mainGrid->reservoirCellIndexByGridAndGridLocalCellIndex( gridIndex, gridCellIndex );
+            size_t parentReservoirCellIdx = m_mainGrid->reservoirCellIndexByGridAndGridLocalCellIndex( gridIndex, gridCellIndex );
             m_gridCellsWithSubCellWellConnections.insert( parentReservoirCellIdx );
         }
     }
@@ -1695,8 +1654,7 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
                     //  If several grids have a wellhead definition for this well, we use the last one.
                     // (Possibly the innermost LGR)
 
-                    const well_conn_type* ert_wellhead =
-                        well_state_iget_wellhead( ert_well_state, static_cast<int>( gridNr ) );
+                    const well_conn_type* ert_wellhead = well_state_iget_wellhead( ert_well_state, static_cast<int>( gridNr ) );
                     if ( ert_wellhead )
                     {
                         wellResFrame.m_wellHead = createWellResultPoint( grids[gridNr], ert_wellhead, -1, -1, wellName );
@@ -1750,9 +1708,8 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
 
                             if ( well_segment_has_grid_connections( segment, gridName.data() ) )
                             {
-                                const well_conn_collection_type* connections =
-                                    well_segment_get_connections( segment, gridName.data() );
-                                int connectionCount = well_conn_collection_get_size( connections );
+                                const well_conn_collection_type* connections     = well_segment_get_connections( segment, gridName.data() );
+                                int                              connectionCount = well_conn_collection_get_size( connections );
 
                                 // Loop backwards to put the deepest connections first in the array. (The segments are
                                 // also traversed deep to shallow)
@@ -1760,11 +1717,7 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
                                 {
                                     well_conn_type* ert_connection = well_conn_collection_iget( connections, connIdx );
                                     wellResultBranch.m_branchResultPoints.push_back(
-                                        createWellResultPoint( grids[gridNr],
-                                                               ert_connection,
-                                                               branchId,
-                                                               well_segment_get_id( segment ),
-                                                               wellName ) );
+                                        createWellResultPoint( grids[gridNr], ert_connection, branchId, well_segment_get_id( segment ), wellName ) );
                                 }
 
                                 segmentHasConnections = true;
@@ -1772,11 +1725,8 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
                                 // Prepare data for segment position calculation
 
                                 well_conn_type*    ert_connection = well_conn_collection_iget( connections, 0 );
-                                RigWellResultPoint point          = createWellResultPoint( grids[gridNr],
-                                                                                  ert_connection,
-                                                                                  branchId,
-                                                                                  well_segment_get_id( segment ),
-                                                                                  wellName );
+                                RigWellResultPoint point =
+                                    createWellResultPoint( grids[gridNr], ert_connection, branchId, well_segment_get_id( segment ), wellName );
                                 lastConnectionPos = grids[gridNr]->cell( point.m_gridCellIndex ).center();
                                 cvf::Vec3d cellVxes[8];
                                 grids[gridNr]->cellCornerVertices( point.m_gridCellIndex, cellVxes );
@@ -1785,8 +1735,7 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
 
                                 lastConnectionSegmentId     = well_segment_get_id( segment );
                                 accLengthFromLastConnection = well_segment_get_length( segment ) / ( connectionCount + 1 );
-                                if ( !segmentBelowHasConnections )
-                                    upperSegmentIdsOfUnpositionedSegementGroup.push_back( segmentIdBelow );
+                                if ( !segmentBelowHasConnections ) upperSegmentIdsOfUnpositionedSegementGroup.push_back( segmentIdBelow );
 
                                 break; // Stop looping over grids
                             }
@@ -1846,13 +1795,11 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
 
                             if ( well_segment_has_grid_connections( outletSegment, gridName.data() ) )
                             {
-                                const well_conn_collection_type* connections =
-                                    well_segment_get_connections( outletSegment, gridName.data() );
-                                int connectionCount = well_conn_collection_get_size( connections );
+                                const well_conn_collection_type* connections = well_segment_get_connections( outletSegment, gridName.data() );
+                                int                              connectionCount = well_conn_collection_get_size( connections );
 
                                 // Select the deepest connection
-                                well_conn_type* ert_connection =
-                                    well_conn_collection_iget( connections, connectionCount - 1 );
+                                well_conn_type* ert_connection = well_conn_collection_iget( connections, connectionCount - 1 );
 
                                 auto resultPoint = createWellResultPoint( grids[gridNr],
                                                                           ert_connection,
@@ -1970,8 +1917,7 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
 
                     // Reverse the order of the resultpoints in this branch, making the deepest come last
 
-                    std::reverse( wellResultBranch.m_branchResultPoints.begin(),
-                                  wellResultBranch.m_branchResultPoints.end() );
+                    std::reverse( wellResultBranch.m_branchResultPoints.begin(), wellResultBranch.m_branchResultPoints.end() );
                 } // End of the branch loop
 
                 // Propagate position contributions from connections above unpositioned segments downwards
@@ -2008,8 +1954,7 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
                                     prevResPoint = wellResultBranch.m_branchResultPoints[rpIdx - 1];
                                 }
 
-                                cvf::Vec3d lastConnectionPos =
-                                    grids[prevResPoint.m_gridIndex]->cell( prevResPoint.m_gridCellIndex ).center();
+                                cvf::Vec3d lastConnectionPos = grids[prevResPoint.m_gridIndex]->cell( prevResPoint.m_gridCellIndex ).center();
 
                                 SegmentPositionContribution posContrib( prevResPoint.m_ertSegmentId,
                                                                         lastConnectionPos,
@@ -2032,10 +1977,7 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
                                 }
                                 posContributions.push_back( posContrib );
 
-                                propagatePosContribDownwards( segmentIdToPositionContrib,
-                                                              allErtSegments,
-                                                              ertSegmentId,
-                                                              posContributions );
+                                propagatePosContribDownwards( segmentIdToPositionContrib, allErtSegments, ertSegmentId, posContributions );
                             }
 
                             previousResultPointWasCell = false;
@@ -2046,9 +1988,8 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
                 // Calculate the bottom position of all the unpositioned segments
                 // Then do the calculation based on the refined contributions
 
-                std::map<int, std::vector<SegmentPositionContribution>>::iterator posContribIt =
-                    segmentIdToPositionContrib.begin();
-                std::map<int, cvf::Vec3d> bottomPositions;
+                std::map<int, std::vector<SegmentPositionContribution>>::iterator posContribIt = segmentIdToPositionContrib.begin();
+                std::map<int, cvf::Vec3d>                                         bottomPositions;
                 while ( posContribIt != segmentIdToPositionContrib.end() )
                 {
                     bottomPositions[posContribIt->first] = interpolate3DPosition( posContribIt->second );
@@ -2079,12 +2020,10 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
                 int                                           lastGridNr = static_cast<int>( grids.size() ) - 1;
                 for ( int gridNr = 0; gridNr <= lastGridNr; ++gridNr )
                 {
-                    const well_conn_type* ert_wellhead =
-                        well_state_iget_wellhead( ert_well_state, static_cast<int>( gridNr ) );
+                    const well_conn_type* ert_wellhead = well_state_iget_wellhead( ert_well_state, static_cast<int>( gridNr ) );
                     if ( ert_wellhead )
                     {
-                        RigWellResultPoint wellHeadRp =
-                            createWellResultPoint( grids[gridNr], ert_wellhead, -1, -1, wellName );
+                        RigWellResultPoint wellHeadRp = createWellResultPoint( grids[gridNr], ert_wellhead, -1, -1, wellName );
                         // HACK: Ert returns open as "this is equally wrong as closed for well heads".
                         // Well heads are not open jfr mail communication with HHGS and JH Statoil 07.01.2016
                         wellHeadRp.m_isOpen = false;
@@ -2112,8 +2051,7 @@ void RifReaderEclipseOutput::readWellCells( const ecl_grid_type* mainEclGrid, bo
                             for ( int connIdx = 0; connIdx < connectionCount; connIdx++ )
                             {
                                 well_conn_type*    ert_connection = well_conn_collection_iget( connections, connIdx );
-                                RigWellResultPoint wellRp =
-                                    createWellResultPoint( grids[gridNr], ert_connection, -1, -1, wellName );
+                                RigWellResultPoint wellRp = createWellResultPoint( grids[gridNr], ert_connection, -1, -1, wellName );
 
                                 if ( !subCellConnCalc.hasSubCellConnection( wellRp ) )
                                 {
@@ -2182,8 +2120,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
         bool validKeyword = false;
 
         size_t timeStepsAllCellsRest = keywordDataItemCount % matrixActiveCellInfo->reservoirCellCount();
-        if ( timeStepsAllCellsRest == 0 &&
-             keywordDataItemCount <= timeStepCount * matrixActiveCellInfo->reservoirCellCount() )
+        if ( timeStepsAllCellsRest == 0 && keywordDataItemCount <= timeStepCount * matrixActiveCellInfo->reservoirCellCount() )
         {
             // Found result for all cells for N time steps, usually a static dataset for one time step
             validKeyword = true;
@@ -2204,8 +2141,8 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
 
             if ( porosityModel == RiaDefines::PorosityModelType::MATRIX_MODEL && timeStepsMatrixRest == 0 )
             {
-                if ( keywordDataItemCount <= timeStepCount * std::max( matrixActiveCellInfo->reservoirActiveCellCount(),
-                                                                       sumFractureMatrixActiveCellCount ) )
+                if ( keywordDataItemCount <=
+                     timeStepCount * std::max( matrixActiveCellInfo->reservoirActiveCellCount(), sumFractureMatrixActiveCellCount ) )
                 {
                     validKeyword = true;
                 }
@@ -2213,8 +2150,8 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
             else if ( porosityModel == RiaDefines::PorosityModelType::FRACTURE_MODEL &&
                       fractureActiveCellInfo->reservoirActiveCellCount() > 0 && timeStepsFractureRest == 0 )
             {
-                if ( keywordDataItemCount <= timeStepCount * std::max( fractureActiveCellInfo->reservoirActiveCellCount(),
-                                                                       sumFractureMatrixActiveCellCount ) )
+                if ( keywordDataItemCount <=
+                     timeStepCount * std::max( fractureActiveCellInfo->reservoirActiveCellCount(), sumFractureMatrixActiveCellCount ) )
                 {
                     validKeyword = true;
                 }
@@ -2236,8 +2173,7 @@ QStringList RifReaderEclipseOutput::validKeywordsForPorosityModel( const QString
                 size_t mainGridMatrixActiveCellCount   = matrixActiveCellInfo->gridActiveCellCounts( 0 );
                 size_t mainGridFractureActiveCellCount = fractureActiveCellInfo->gridActiveCellCounts( 0 );
 
-                if ( keywordDataItemCount == mainGridMatrixActiveCellCount ||
-                     keywordDataItemCount == mainGridFractureActiveCellCount ||
+                if ( keywordDataItemCount == mainGridMatrixActiveCellCount || keywordDataItemCount == mainGridFractureActiveCellCount ||
                      keywordDataItemCount == mainGridMatrixActiveCellCount + mainGridFractureActiveCellCount )
                 {
                     validKeyword = true;
@@ -2277,9 +2213,8 @@ std::vector<RigEclipseTimeStepInfo> RifReaderEclipseOutput::createFilteredTimeSt
         {
             if ( this->isTimeStepIncludedByFilter( i ) )
             {
-                timeStepInfos.push_back( RigEclipseTimeStepInfo( timeStepsOnFile[i],
-                                                                 reportNumbersOnFile[i],
-                                                                 daysSinceSimulationStartOnFile[i] ) );
+                timeStepInfos.push_back(
+                    RigEclipseTimeStepInfo( timeStepsOnFile[i], reportNumbersOnFile[i], daysSinceSimulationStartOnFile[i] ) );
             }
         }
     }
@@ -2290,8 +2225,7 @@ std::vector<RigEclipseTimeStepInfo> RifReaderEclipseOutput::createFilteredTimeSt
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifReaderEclipseOutput::isEclipseAndSoursimTimeStepsEqual( const QDateTime& eclipseDateTime,
-                                                                const QDateTime& sourSimDateTime )
+bool RifReaderEclipseOutput::isEclipseAndSoursimTimeStepsEqual( const QDateTime& eclipseDateTime, const QDateTime& sourSimDateTime )
 {
     // Compare date down to and including seconds
     // Compare of complete date time objects will often result in differences
@@ -2334,8 +2268,7 @@ ecl_grid_type* RifReaderEclipseOutput::loadAllGrids() const
 
         bool isDualPorosity    = ecl_grid_dual_grid( mainEclGrid );
         auto cellCountMainGrid = ecl_grid_get_global_size( mainEclGrid );
-        auto activeCells =
-            RifActiveCellsReader::activeCellsFromPorvKeyword( m_ecl_init_file, isDualPorosity, cellCountMainGrid );
+        auto activeCells       = RifActiveCellsReader::activeCellsFromPorvKeyword( m_ecl_init_file, isDualPorosity, cellCountMainGrid );
 
         if ( !activeCells.empty() )
         {
@@ -2361,8 +2294,8 @@ void RifReaderEclipseOutput::updateFromGridCount( size_t gridCount )
 ///
 //--------------------------------------------------------------------------------------------------
 void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel( RiaDefines::PorosityModelType matrixOrFracture,
-                                                                      std::vector<double>* destinationResultValues,
-                                                                      const std::vector<double>& sourceResultValues )
+                                                                      std::vector<double>*          destinationResultValues,
+                                                                      const std::vector<double>&    sourceResultValues )
 {
     if ( sourceResultValues.size() == 0 ) return;
 
@@ -2370,9 +2303,7 @@ void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel( RiaDefines
 
     if ( matrixOrFracture == RiaDefines::PorosityModelType::MATRIX_MODEL && fracActCellInfo->reservoirActiveCellCount() == 0 )
     {
-        destinationResultValues->insert( destinationResultValues->end(),
-                                         sourceResultValues.begin(),
-                                         sourceResultValues.end() );
+        destinationResultValues->insert( destinationResultValues->end(), sourceResultValues.begin(), sourceResultValues.end() );
     }
     else
     {
@@ -2403,8 +2334,8 @@ void RifReaderEclipseOutput::extractResultValuesBasedOnPorosityModel( RiaDefines
 
                 destinationResultValues->insert( destinationResultValues->end(),
                                                  sourceResultValues.begin() + sourceStartPosition + matrixActiveCellCount,
-                                                 sourceResultValues.begin() + sourceStartPosition +
-                                                     matrixActiveCellCount + fractureActiveCellCount );
+                                                 sourceResultValues.begin() + sourceStartPosition + matrixActiveCellCount +
+                                                     fractureActiveCellCount );
             }
 
             sourceStartPosition += ( matrixActiveCellCount + fractureActiveCellCount );
@@ -2425,8 +2356,7 @@ void RifReaderEclipseOutput::openInitFile()
     QString initFileName = RifEclipseOutputFileTools::firstFileNameOfType( m_filesWithSameBaseName, ECL_INIT_FILE );
     if ( initFileName.size() > 0 )
     {
-        m_ecl_init_file =
-            ecl_file_open( RiaStringEncodingTools::toNativeEncoded( initFileName ).data(), ECL_FILE_CLOSE_STREAM );
+        m_ecl_init_file = ecl_file_open( RiaStringEncodingTools::toNativeEncoded( initFileName ).data(), ECL_FILE_CLOSE_STREAM );
     }
 }
 

ApplicationLibCode/FileInterface/RifReaderEclipseOutput.h

@@ -60,26 +60,18 @@ public:
 
     static const size_t* eclipseCellIndexMapping();
 
-    bool openAndReadActiveCellData( const QString&                fileName,
-                                    const std::vector<QDateTime>& mainCaseTimeSteps,
-                                    RigEclipseCaseData*           eclipseCase );
+    bool openAndReadActiveCellData( const QString& fileName, const std::vector<QDateTime>& mainCaseTimeSteps, RigEclipseCaseData* eclipseCase );
 
-    bool staticResult( const QString&                result,
-                       RiaDefines::PorosityModelType matrixOrFracture,
-                       std::vector<double>*          values ) override;
-    bool dynamicResult( const QString&                result,
-                        RiaDefines::PorosityModelType matrixOrFracture,
-                        size_t                        stepIndex,
-                        std::vector<double>*          values ) override;
+    bool staticResult( const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values ) override;
+    bool dynamicResult( const QString& result, RiaDefines::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values ) override;
     void sourSimRlResult( const QString& result, size_t stepIndex, std::vector<double>* values );
 
     std::vector<QDateTime> allTimeSteps() const;
 
     static bool transferGeometry( const ecl_grid_type* mainEclGrid, RigEclipseCaseData* eclipseCase );
     static void transferCoarseningInfo( const ecl_grid_type* eclGrid, RigGridBase* grid );
-    static void importEquilData( const QString&      deckFileName,
-                                 const QString&      includeStatementAbsolutePathPrefix,
-                                 RigEclipseCaseData* eclipseCase );
+    static void
+        importEquilData( const QString& deckFileName, const QString& includeStatementAbsolutePathPrefix, RigEclipseCaseData* eclipseCase );
 
     std::set<RiaDefines::PhaseType> availablePhases() const override;
 

ApplicationLibCode/FileInterface/RifReaderEclipseRft.cpp

@@ -275,9 +275,8 @@ void RifReaderEclipseRft::cellIndices( const RifEclipseRftAddress& rftAddress, s
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<QDateTime>
-    RifReaderEclipseRft::availableTimeSteps( const QString&                                     wellName,
-                                             const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
+std::set<QDateTime> RifReaderEclipseRft::availableTimeSteps( const QString&                                     wellName,
+                                                             const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
 {
     if ( !m_ecl_rft_file )
     {
@@ -301,9 +300,8 @@ std::set<QDateTime>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<QDateTime>
-    RifReaderEclipseRft::availableTimeSteps( const QString&                                               wellName,
-                                             const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
+std::set<QDateTime> RifReaderEclipseRft::availableTimeSteps( const QString&                                               wellName,
+                                                             const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
 {
     if ( !m_ecl_rft_file )
     {

ApplicationLibCode/FileInterface/RifReaderEclipseRft.h

@@ -44,13 +44,12 @@ public:
     ~RifReaderEclipseRft() override;
 
     std::set<RifEclipseRftAddress> eclipseRftAddresses() override;
-    void values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) override;
-    void cellIndices( const RifEclipseRftAddress& rftAddress, std::vector<caf::VecIjk>* indices ) override;
+    void                           values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) override;
+    void                           cellIndices( const RifEclipseRftAddress& rftAddress, std::vector<caf::VecIjk>* indices ) override;
 
     std::set<QDateTime> availableTimeSteps( const QString& wellName ) override;
-    std::set<QDateTime>
-        availableTimeSteps( const QString&                                               wellName,
-                            const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels ) override;
+    std::set<QDateTime> availableTimeSteps( const QString&                                               wellName,
+                                            const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels ) override;
 
     std::set<QDateTime>                                   availableTimeSteps( const QString&                                     wellName,
                                                                               const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName ) override;

ApplicationLibCode/FileInterface/RifReaderEclipseSummary.cpp

@@ -92,16 +92,13 @@ bool RifReaderEclipseSummary::open( const QString& headerFileName, RiaThreadSafe
         bool h5FileFound = QFile::exists( h5FileName );
 
         if ( !prefSummary->createEnhancedSummaryDataFiles() &&
-             ( h5FileFound ||
-               ( prefSummary->summaryDataReader() == RiaPreferencesSummary::SummaryReaderMode::HDF5_OPM_COMMON ) ) )
+             ( h5FileFound || ( prefSummary->summaryDataReader() == RiaPreferencesSummary::SummaryReaderMode::HDF5_OPM_COMMON ) ) )
         {
 #ifdef USE_HDF5
             if ( prefSummary->createH5SummaryDataFiles() )
             {
                 size_t createdH5FileCount = 0;
-                RifHdf5SummaryExporter::ensureHdf5FileIsCreated( headerFileName.toStdString(),
-                                                                 h5FileName.toStdString(),
-                                                                 createdH5FileCount );
+                RifHdf5SummaryExporter::ensureHdf5FileIsCreated( headerFileName.toStdString(), h5FileName.toStdString(), createdH5FileCount );
 
                 if ( createdH5FileCount > 0 )
                 {
@@ -182,8 +179,7 @@ bool RifReaderEclipseSummary::values( const RifEclipseSummaryAddress& resultAddr
     if ( m_differenceAddresses.count( resultAddress ) )
     {
         const std::string& quantityName = resultAddress.vectorName();
-        auto historyQuantity = quantityName.substr( 0, quantityName.size() - differenceIdentifier().size() ) +
-                               historyIdentifier();
+        auto historyQuantity = quantityName.substr( 0, quantityName.size() - differenceIdentifier().size() ) + historyIdentifier();
 
         RifEclipseSummaryAddress nativeAdrNoHistory = resultAddress;
         nativeAdrNoHistory.setVectorName( historyQuantity );
@@ -354,8 +350,7 @@ RifReaderEclipseSummary::ValuesCache::~ValuesCache()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifReaderEclipseSummary::ValuesCache::insertValues( const RifEclipseSummaryAddress& address,
-                                                         const std::vector<double>&      values )
+void RifReaderEclipseSummary::ValuesCache::insertValues( const RifEclipseSummaryAddress& address, const std::vector<double>& values )
 {
     m_cachedValues[address] = values;
 }

ApplicationLibCode/FileInterface/RifReaderEclipseSummary.h

@@ -51,8 +51,8 @@ public:
 
     std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
 
-    bool        values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
-    std::string unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
+    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::string                   unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem unitSystem() const override;
 
     static std::string       differenceIdentifier() { return "_DIFF"; }
@@ -79,7 +79,7 @@ private:
         ValuesCache();
         ~ValuesCache();
 
-        void insertValues( const RifEclipseSummaryAddress& address, const std::vector<double>& values );
+        void                       insertValues( const RifEclipseSummaryAddress& address, const std::vector<double>& values );
         const std::vector<double>& getValues( const RifEclipseSummaryAddress& address ) const;
 
     private:

ApplicationLibCode/FileInterface/RifReaderEnsembleStatisticsRft.cpp

@@ -59,11 +59,10 @@ std::set<RifEclipseRftAddress> RifReaderEnsembleStatisticsRft::eclipseRftAddress
         }
         else if ( regularAddress.wellLogChannel() == RifEclipseRftAddress::RftWellLogChannelType::PRESSURE )
         {
-            std::set<RifEclipseRftAddress::RftWellLogChannelType> statChannels =
-                { RifEclipseRftAddress::RftWellLogChannelType::PRESSURE_P10,
-                  RifEclipseRftAddress::RftWellLogChannelType::PRESSURE_P50,
-                  RifEclipseRftAddress::RftWellLogChannelType::PRESSURE_P90,
-                  RifEclipseRftAddress::RftWellLogChannelType::PRESSURE_MEAN };
+            std::set<RifEclipseRftAddress::RftWellLogChannelType> statChannels = { RifEclipseRftAddress::RftWellLogChannelType::PRESSURE_P10,
+                                                                                   RifEclipseRftAddress::RftWellLogChannelType::PRESSURE_P50,
+                                                                                   RifEclipseRftAddress::RftWellLogChannelType::PRESSURE_P90,
+                                                                                   RifEclipseRftAddress::RftWellLogChannelType::PRESSURE_MEAN };
             for ( auto channel : statChannels )
             {
                 statisticsAddresses.insert(
@@ -114,9 +113,8 @@ std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps( const QS
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<QDateTime>
-    RifReaderEnsembleStatisticsRft::availableTimeSteps( const QString&                                     wellName,
-                                                        const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
+std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps( const QString&                                     wellName,
+                                                                        const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
 {
     std::set<QDateTime> allTimeSteps;
     for ( auto summaryCase : m_summaryCaseCollection->allSummaryCases() )
@@ -133,9 +131,9 @@ std::set<QDateTime>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps(
-    const QString&                                               wellName,
-    const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
+std::set<QDateTime>
+    RifReaderEnsembleStatisticsRft::availableTimeSteps( const QString&                                               wellName,
+                                                        const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
 {
     std::set<QDateTime> allTimeSteps;
     for ( auto summaryCase : m_summaryCaseCollection->allSummaryCases() )
@@ -152,8 +150,7 @@ std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps(
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<RifEclipseRftAddress::RftWellLogChannelType>
-    RifReaderEnsembleStatisticsRft::availableWellLogChannels( const QString& wellName )
+std::set<RifEclipseRftAddress::RftWellLogChannelType> RifReaderEnsembleStatisticsRft::availableWellLogChannels( const QString& wellName )
 {
     std::set<RifEclipseRftAddress::RftWellLogChannelType> allWellLogChannels;
     for ( auto summaryCase : m_summaryCaseCollection->allSummaryCases() )
@@ -247,12 +244,7 @@ void RifReaderEnsembleStatisticsRft::calculateStatistics( const RifEclipseRftAdd
                 pressuresAtDepth.push_back( curvePressures[depthIdx] );
             }
             double p10, p50, p90, mean;
-            RigStatisticsMath::calculateStatisticsCurves( pressuresAtDepth,
-                                                          &p10,
-                                                          &p50,
-                                                          &p90,
-                                                          &mean,
-                                                          RigStatisticsMath::PercentileStyle::SWITCHED );
+            RigStatisticsMath::calculateStatisticsCurves( pressuresAtDepth, &p10, &p50, &p90, &mean, RigStatisticsMath::PercentileStyle::SWITCHED );
 
             m_cachedValues[depthAddress].push_back( allDepths[depthIdx] );
 

ApplicationLibCode/FileInterface/RifReaderEnsembleStatisticsRft.h

@@ -30,13 +30,12 @@ public:
     RifReaderEnsembleStatisticsRft( const RimSummaryCaseCollection* summaryCaseCollection );
 
     std::set<RifEclipseRftAddress> eclipseRftAddresses() override;
-    void values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) override;
+    void                           values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) override;
 
-    std::set<QDateTime> availableTimeSteps( const QString& wellName ) override;
-    std::set<QDateTime> availableTimeSteps( const QString&                                     wellName,
-                                            const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName ) override;
-    std::set<QDateTime>
-                                                          availableTimeSteps( const QString&                                               wellName,
+    std::set<QDateTime>                                   availableTimeSteps( const QString& wellName ) override;
+    std::set<QDateTime>                                   availableTimeSteps( const QString&                                     wellName,
+                                                                              const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName ) override;
+    std::set<QDateTime>                                   availableTimeSteps( const QString&                                               wellName,
                                                                               const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels ) override;
     std::set<RifEclipseRftAddress::RftWellLogChannelType> availableWellLogChannels( const QString& wellName ) override;
     std::set<QString>                                     wellNames() override;

ApplicationLibCode/FileInterface/RifReaderFmuRft.cpp

@@ -50,8 +50,7 @@ bool RifReaderFmuRft::Observation::valid() const
 {
     return utmx != std::numeric_limits<double>::infinity() && utmy != std::numeric_limits<double>::infinity() &&
            mdrkb != std::numeric_limits<double>::infinity() && tvdmsl != std::numeric_limits<double>::infinity() &&
-           pressure != std::numeric_limits<double>::infinity() &&
-           pressureError != std::numeric_limits<double>::infinity();
+           pressure != std::numeric_limits<double>::infinity() && pressureError != std::numeric_limits<double>::infinity();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -165,10 +164,8 @@ std::vector<QString> RifReaderFmuRft::labels( const RifEclipseRftAddress& rftAdd
         const std::vector<Observation>& observations = it->second.observations;
         for ( const Observation& observation : observations )
         {
-            formationLabels.push_back( QString( "%1 - Pressure: %2 +/- %3" )
-                                           .arg( observation.formation )
-                                           .arg( observation.pressure )
-                                           .arg( observation.pressureError ) );
+            formationLabels.push_back(
+                QString( "%1 - Pressure: %2 +/- %3" ).arg( observation.formation ).arg( observation.pressure ).arg( observation.pressureError ) );
         }
     }
     return formationLabels;
@@ -196,19 +193,13 @@ std::set<RifEclipseRftAddress> RifReaderFmuRft::eclipseRftAddresses()
             if ( observation.valid() )
             {
                 RifEclipseRftAddress tvdAddress =
-                    RifEclipseRftAddress::createAddress( wellName,
-                                                         dateTime,
-                                                         RifEclipseRftAddress::RftWellLogChannelType::TVD );
+                    RifEclipseRftAddress::createAddress( wellName, dateTime, RifEclipseRftAddress::RftWellLogChannelType::TVD );
                 RifEclipseRftAddress mdAddress =
                     RifEclipseRftAddress::createAddress( wellName, dateTime, RifEclipseRftAddress::RftWellLogChannelType::MD );
                 RifEclipseRftAddress pressureAddress =
-                    RifEclipseRftAddress::createAddress( wellName,
-                                                         dateTime,
-                                                         RifEclipseRftAddress::RftWellLogChannelType::PRESSURE );
+                    RifEclipseRftAddress::createAddress( wellName, dateTime, RifEclipseRftAddress::RftWellLogChannelType::PRESSURE );
                 RifEclipseRftAddress pressureErrorAddress =
-                    RifEclipseRftAddress::createAddress( wellName,
-                                                         dateTime,
-                                                         RifEclipseRftAddress::RftWellLogChannelType::PRESSURE_ERROR );
+                    RifEclipseRftAddress::createAddress( wellName, dateTime, RifEclipseRftAddress::RftWellLogChannelType::PRESSURE_ERROR );
                 allAddresses.insert( tvdAddress );
                 allAddresses.insert( mdAddress );
                 allAddresses.insert( pressureAddress );
@@ -316,9 +307,8 @@ void RifReaderFmuRft::load()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<QDateTime>
-    RifReaderFmuRft::availableTimeSteps( const QString&                                     wellName,
-                                         const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
+std::set<QDateTime> RifReaderFmuRft::availableTimeSteps( const QString&                                     wellName,
+                                                         const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
 {
     if ( wellLogChannelName == RifEclipseRftAddress::RftWellLogChannelType::TVD ||
          wellLogChannelName == RifEclipseRftAddress::RftWellLogChannelType::MD ||
@@ -350,9 +340,8 @@ std::set<QDateTime> RifReaderFmuRft::availableTimeSteps( const QString& wellName
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<QDateTime>
-    RifReaderFmuRft::availableTimeSteps( const QString&                                               wellName,
-                                         const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
+std::set<QDateTime> RifReaderFmuRft::availableTimeSteps( const QString&                                               wellName,
+                                                         const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
 {
     if ( relevantChannels.count( RifEclipseRftAddress::RftWellLogChannelType::TVD ) ||
          relevantChannels.count( RifEclipseRftAddress::RftWellLogChannelType::MD ) ||

ApplicationLibCode/FileInterface/RifReaderFmuRft.h

@@ -72,10 +72,9 @@ public:
     std::vector<QString> labels( const RifEclipseRftAddress& rftAddress );
 
     std::set<RifEclipseRftAddress> eclipseRftAddresses() override;
-    void values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) override;
+    void                           values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) override;
 
-    std::set<QDateTime>
-                        availableTimeSteps( const QString&                                               wellName,
+    std::set<QDateTime> availableTimeSteps( const QString&                                               wellName,
                                             const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels ) override;
     std::set<QDateTime> availableTimeSteps( const QString& wellName ) override;
     std::set<QDateTime> availableTimeSteps( const QString&                                     wellName,
@@ -92,8 +91,8 @@ private:
     typedef std::map<QString, WellObservationSet>        WellObservationMap;
 
     WellObservationMap loadWellDates( QDir& dir, QString* errorMsg );
-    static bool readTxtFile( const QString& txtFileName, QString* errorMsg, WellObservationSet* wellObservationSet );
-    static bool readObsFile( const QString& obsFileName, QString* errorMsg, WellObservationSet* wellObservationSet );
+    static bool        readTxtFile( const QString& txtFileName, QString* errorMsg, WellObservationSet* wellObservationSet );
+    static bool        readObsFile( const QString& obsFileName, QString* errorMsg, WellObservationSet* wellObservationSet );
 
 private:
     QString            m_filePath;

ApplicationLibCode/FileInterface/RifReaderInterface.h

@@ -59,15 +59,13 @@ public:
 
     virtual bool open( const QString& fileName, RigEclipseCaseData* eclipseCase ) = 0;
 
-    virtual bool staticResult( const QString&                result,
-                               RiaDefines::PorosityModelType matrixOrFracture,
-                               std::vector<double>*          values )  = 0;
+    virtual bool staticResult( const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values ) = 0;
     virtual bool dynamicResult( const QString&                result,
                                 RiaDefines::PorosityModelType matrixOrFracture,
                                 size_t                        stepIndex,
-                                std::vector<double>*          values ) = 0;
+                                std::vector<double>*          values )                                                                       = 0;
 
-    void setFilenamesWithFaults( const std::vector<QString>& filenames ) { m_filenamesWithFaults = filenames; }
+    void                 setFilenamesWithFaults( const std::vector<QString>& filenames ) { m_filenamesWithFaults = filenames; }
     std::vector<QString> filenamesWithFaults() { return m_filenamesWithFaults; }
 
     void setTimeStepFilter( const std::vector<size_t>& fileTimeStepIndices );

ApplicationLibCode/FileInterface/RifReaderMockModel.cpp

@@ -55,8 +55,7 @@ bool RifReaderMockModel::open( const QString& fileName, RigEclipseCaseData* ecli
 
     for ( size_t i = 0; i < m_reservoirBuilder.resultCount(); i++ )
     {
-        RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE,
-                                         QString( "Dynamic_Result_%1" ).arg( i ) );
+        RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::DYNAMIC_NATIVE, QString( "Dynamic_Result_%1" ).arg( i ) );
         cellResults->createResultEntry( resAddr, false );
         cellResults->setTimeStepInfos( resAddr, timeStepInfos );
     }
@@ -110,9 +109,7 @@ bool RifReaderMockModel::inputProperty( const QString& propertyName, std::vector
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifReaderMockModel::staticResult( const QString&                result,
-                                       RiaDefines::PorosityModelType matrixOrFracture,
-                                       std::vector<double>*          values )
+bool RifReaderMockModel::staticResult( const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values )
 {
     m_reservoirBuilder.staticResult( m_reservoir, result, values );
 

ApplicationLibCode/FileInterface/RifReaderMockModel.h

@@ -40,13 +40,8 @@ public:
 
     bool open( const QString& fileName, RigEclipseCaseData* eclipseCase ) override;
 
-    bool staticResult( const QString&                result,
-                       RiaDefines::PorosityModelType matrixOrFracture,
-                       std::vector<double>*          values ) override;
-    bool dynamicResult( const QString&                result,
-                        RiaDefines::PorosityModelType matrixOrFracture,
-                        size_t                        stepIndex,
-                        std::vector<double>*          values ) override;
+    bool staticResult( const QString& result, RiaDefines::PorosityModelType matrixOrFracture, std::vector<double>* values ) override;
+    bool dynamicResult( const QString& result, RiaDefines::PorosityModelType matrixOrFracture, size_t stepIndex, std::vector<double>* values ) override;
 
 private:
     void populateReservoir( RigEclipseCaseData* eclipseCase );

ApplicationLibCode/FileInterface/RifReaderObservedData.h

@@ -41,9 +41,7 @@ public:
     RifReaderObservedData();
     ~RifReaderObservedData() override;
 
-    bool open( const QString&                               headerFileName,
-               const QString&                               identifierName,
-               RifEclipseSummaryAddress::SummaryVarCategory summaryCategory );
+    bool open( const QString& headerFileName, const QString& identifierName, RifEclipseSummaryAddress::SummaryVarCategory summaryCategory );
 
     std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
 
@@ -54,9 +52,8 @@ public:
     RiaDefines::EclipseUnitSystem unitSystem() const override;
 
 private:
-    RifEclipseSummaryAddress address( const QString&                               vectorName,
-                                      const QString&                               identifierName,
-                                      RifEclipseSummaryAddress::SummaryVarCategory summaryCategory );
+    RifEclipseSummaryAddress
+        address( const QString& vectorName, const QString& identifierName, RifEclipseSummaryAddress::SummaryVarCategory summaryCategory );
 
 private:
     std::unique_ptr<RifCsvUserDataParser> m_asciiParser;

ApplicationLibCode/FileInterface/RifReaderOpmRft.cpp

@@ -88,8 +88,7 @@ void RifReaderOpmRft::values( const RifEclipseRftAddress& rftAddress, std::vecto
         {
             auto data = segment.topology();
 
-            auto indices =
-                segment.segmentIndicesForBranchIndex( rftAddress.segmentBranchIndex(), rftAddress.segmentBranchType() );
+            auto indices = segment.segmentIndicesForBranchIndex( rftAddress.segmentBranchIndex(), rftAddress.segmentBranchType() );
             for ( const auto& i : indices )
             {
                 CAF_ASSERT( i < data.size() );
@@ -129,12 +128,12 @@ void RifReaderOpmRft::values( const RifEclipseRftAddress& rftAddress, std::vecto
                     // Connection results with size equal to length of result CONSEGNO. CONSEGNO defines the segment
                     // numbers the connection is connected to.
 
-                    const std::string consegResultName = "CONSEGNO";
-                    auto connnectionSegmentNumbers     = m_opm_rft->getRft<int>( consegResultName, wellName, y, m, d );
+                    const std::string consegResultName          = "CONSEGNO";
+                    auto              connnectionSegmentNumbers = m_opm_rft->getRft<int>( consegResultName, wellName, y, m, d );
                     if ( connnectionSegmentNumbers.empty() ) return;
 
-                    auto segmentNumbers = segment.segmentNumbersForBranchIndex( rftAddress.segmentBranchIndex(),
-                                                                                rftAddress.segmentBranchType() );
+                    auto segmentNumbers =
+                        segment.segmentNumbersForBranchIndex( rftAddress.segmentBranchIndex(), rftAddress.segmentBranchType() );
 
                     size_t resultDataIndex = 0;
                     for ( int segmentNumber : segmentNumbers )
@@ -154,8 +153,7 @@ void RifReaderOpmRft::values( const RifEclipseRftAddress& rftAddress, std::vecto
                 }
                 else
                 {
-                    auto indices = segment.segmentIndicesForBranchIndex( rftAddress.segmentBranchIndex(),
-                                                                         rftAddress.segmentBranchType() );
+                    auto indices = segment.segmentIndicesForBranchIndex( rftAddress.segmentBranchIndex(), rftAddress.segmentBranchType() );
                     for ( const auto& i : indices )
                     {
                         CAF_ASSERT( i < data.size() );
@@ -202,14 +200,12 @@ std::set<QDateTime> RifReaderOpmRft::availableTimeSteps( const QString& wellName
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<QDateTime>
-    RifReaderOpmRft::availableTimeSteps( const QString&                                     wellName,
-                                         const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
+std::set<QDateTime> RifReaderOpmRft::availableTimeSteps( const QString&                                     wellName,
+                                                         const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
 {
     openFiles();
 
-    if ( wellLogChannelName == RifEclipseRftAddress::RftWellLogChannelType::SEGMENT_VALUES )
-        return m_rftSegmentTimeSteps;
+    if ( wellLogChannelName == RifEclipseRftAddress::RftWellLogChannelType::SEGMENT_VALUES ) return m_rftSegmentTimeSteps;
 
     std::set<QDateTime> timeSteps;
 
@@ -226,9 +222,8 @@ std::set<QDateTime>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<QDateTime>
-    RifReaderOpmRft::availableTimeSteps( const QString&                                               wellName,
-                                         const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
+std::set<QDateTime> RifReaderOpmRft::availableTimeSteps( const QString&                                               wellName,
+                                                         const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
 {
     openFiles();
 
@@ -316,9 +311,8 @@ void RifReaderOpmRft::cellIndices( const RifEclipseRftAddress& rftAddress, std::
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::map<int, int> RifReaderOpmRft::branchIdsAndOneBasedIndices( const QString&            wellName,
-                                                                 const QDateTime&          timeStep,
-                                                                 RiaDefines::RftBranchType branchType )
+std::map<int, int>
+    RifReaderOpmRft::branchIdsAndOneBasedIndices( const QString& wellName, const QDateTime& timeStep, RiaDefines::RftBranchType branchType )
 {
     int y = timeStep.date().year();
     int m = timeStep.date().month();
@@ -454,16 +448,12 @@ void RifReaderOpmRft::buildMetaData()
         auto resultNameAndSizes = segmentData.resultNameAndSize();
         for ( const auto& [name, arrayType, size] : resultNameAndSizes )
         {
-            auto adr = RifEclipseRftAddress::createSegmentAddress( QString::fromStdString( wellName ),
-                                                                   dt,
-                                                                   QString::fromStdString( name ) );
+            auto adr = RifEclipseRftAddress::createSegmentAddress( QString::fromStdString( wellName ), dt, QString::fromStdString( name ) );
 
             m_addresses.insert( adr );
         }
 
-        auto adr = RifEclipseRftAddress::createSegmentAddress( QString::fromStdString( wellName ),
-                                                               dt,
-                                                               RiaDefines::segmentNumberResultName() );
+        auto adr = RifEclipseRftAddress::createSegmentAddress( QString::fromStdString( wellName ), dt, RiaDefines::segmentNumberResultName() );
 
         m_addresses.insert( adr );
     }
@@ -545,12 +535,10 @@ void RifReaderOpmRft::buildSegmentData()
                 const auto& [name, arrayType, size] = rftResultMetaData;
 
                 bool isResultItemCountValid = false;
-                if ( m_segmentResultItemCount.count( wellName ) &&
-                     size == static_cast<int64_t>( m_segmentResultItemCount[wellName] ) )
+                if ( m_segmentResultItemCount.count( wellName ) && size == static_cast<int64_t>( m_segmentResultItemCount[wellName] ) )
                     isResultItemCountValid = true;
 
-                if ( m_connectionResultItemCount.count( wellName ) &&
-                     size == static_cast<int64_t>( m_connectionResultItemCount[wellName] ) )
+                if ( m_connectionResultItemCount.count( wellName ) && size == static_cast<int64_t>( m_connectionResultItemCount[wellName] ) )
                     isResultItemCountValid = true;
 
                 if ( isResultItemCountValid )
@@ -882,8 +870,7 @@ void RifReaderOpmRft::identifyDeviceBranches( RifRftSegment& segmentRef, const s
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<int>
-    RifReaderOpmRft::importWellData( const std::string& wellName, const std::string& propertyName, const RftDate& date ) const
+std::vector<int> RifReaderOpmRft::importWellData( const std::string& wellName, const std::string& propertyName, const RftDate& date ) const
 {
     // PERFORMANCE NOTE
     // Use method hasRft() that do not throw exception if RFT data is not available. Using this method and avoid
@@ -971,8 +958,7 @@ std::string RifReaderOpmRft::resultNameFromChannelType( RifEclipseRftAddress::Rf
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<float>
-    RifReaderOpmRft::resultAsFloat( const std::string& resultName, const std::string& wellName, int year, int month, int day ) const
+std::vector<float> RifReaderOpmRft::resultAsFloat( const std::string& resultName, const std::string& wellName, int year, int month, int day ) const
 {
     Opm::EclIO::eclArrType resultDataType = Opm::EclIO::eclArrType::REAL;
 

ApplicationLibCode/FileInterface/RifReaderOpmRft.h

@@ -40,22 +40,19 @@ public:
     RifReaderOpmRft( const QString& fileName, const QString& dataDeckFileName );
 
     std::set<RifEclipseRftAddress> eclipseRftAddresses() override;
-    void values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) override;
+    void                           values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) override;
 
-    std::set<QDateTime> availableTimeSteps( const QString& wellName ) override;
-    std::set<QDateTime> availableTimeSteps( const QString&                                     wellName,
-                                            const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName ) override;
-    std::set<QDateTime>
-                                                          availableTimeSteps( const QString&                                               wellName,
+    std::set<QDateTime>                                   availableTimeSteps( const QString& wellName ) override;
+    std::set<QDateTime>                                   availableTimeSteps( const QString&                                     wellName,
+                                                                              const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName ) override;
+    std::set<QDateTime>                                   availableTimeSteps( const QString&                                               wellName,
                                                                               const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels ) override;
     std::set<RifEclipseRftAddress::RftWellLogChannelType> availableWellLogChannels( const QString& wellName ) override;
     std::set<QString>                                     wellNames() override;
 
     void cellIndices( const RifEclipseRftAddress& rftAddress, std::vector<caf::VecIjk>* indices ) override;
 
-    std::map<int, int> branchIdsAndOneBasedIndices( const QString&            wellName,
-                                                    const QDateTime&          timeStep,
-                                                    RiaDefines::RftBranchType branchType );
+    std::map<int, int> branchIdsAndOneBasedIndices( const QString& wellName, const QDateTime& timeStep, RiaDefines::RftBranchType branchType );
 
     RifRftSegment segmentForWell( const QString& wellName, const QDateTime& timeStep );
 
@@ -87,10 +84,9 @@ private:
     std::vector<int>                 annulusSegmentsForWell( const std::string& wellName ) const;
 
     static RifEclipseRftAddress::RftWellLogChannelType identifyChannelType( const std::string& resultName );
-    static std::string resultNameFromChannelType( RifEclipseRftAddress::RftWellLogChannelType channelType );
+    static std::string                                 resultNameFromChannelType( RifEclipseRftAddress::RftWellLogChannelType channelType );
 
-    std::vector<float>
-        resultAsFloat( const std::string& resultName, const std::string& wellName, int year, int month, int day ) const;
+    std::vector<float> resultAsFloat( const std::string& resultName, const std::string& wellName, int year, int month, int day ) const;
 
     bool openFiles();
 

ApplicationLibCode/FileInterface/RifReaderPressureDepthData.cpp

@@ -45,12 +45,10 @@ std::vector<QString> RifReaderPressureDepthData::labels( const RifEclipseRftAddr
 
     for ( const RigPressureDepthData& pressureDepthData : m_pressureDepthDataItems )
     {
-        if ( rftAddress.wellName() == pressureDepthData.wellName() &&
-             rftAddress.timeStep().date() == pressureDepthData.timeStep().date() )
+        if ( rftAddress.wellName() == pressureDepthData.wellName() && rftAddress.timeStep().date() == pressureDepthData.timeStep().date() )
         {
-            formationLabels.push_back( QString( "%1 - Pressure: %2" )
-                                           .arg( pressureDepthData.wellName() )
-                                           .arg( pressureDepthData.timeStep().toString() ) );
+            formationLabels.push_back(
+                QString( "%1 - Pressure: %2" ).arg( pressureDepthData.wellName() ).arg( pressureDepthData.timeStep().toString() ) );
         }
     }
 
@@ -98,8 +96,7 @@ void RifReaderPressureDepthData::values( const RifEclipseRftAddress& rftAddress,
 
     for ( const RigPressureDepthData& pressureDepthData : m_pressureDepthDataItems )
     {
-        if ( rftAddress.wellName() == pressureDepthData.wellName() &&
-             rftAddress.timeStep().date() == pressureDepthData.timeStep().date() )
+        if ( rftAddress.wellName() == pressureDepthData.wellName() && rftAddress.timeStep().date() == pressureDepthData.timeStep().date() )
         {
             switch ( rftAddress.wellLogChannel() )
             {
@@ -135,9 +132,8 @@ void RifReaderPressureDepthData::load()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<QDateTime>
-    RifReaderPressureDepthData::availableTimeSteps( const QString&                                     wellName,
-                                                    const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
+std::set<QDateTime> RifReaderPressureDepthData::availableTimeSteps( const QString&                                     wellName,
+                                                                    const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
 {
     if ( wellLogChannelName == RifEclipseRftAddress::RftWellLogChannelType::TVD ||
          wellLogChannelName == RifEclipseRftAddress::RftWellLogChannelType::PRESSURE )
@@ -171,9 +167,8 @@ std::set<QDateTime> RifReaderPressureDepthData::availableTimeSteps( const QStrin
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<QDateTime> RifReaderPressureDepthData::availableTimeSteps(
-    const QString&                                               wellName,
-    const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
+std::set<QDateTime> RifReaderPressureDepthData::availableTimeSteps( const QString&                                               wellName,
+                                                                    const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
 {
     if ( relevantChannels.count( RifEclipseRftAddress::RftWellLogChannelType::TVD ) ||
          relevantChannels.count( RifEclipseRftAddress::RftWellLogChannelType::PRESSURE ) )
@@ -186,8 +181,7 @@ std::set<QDateTime> RifReaderPressureDepthData::availableTimeSteps(
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<RifEclipseRftAddress::RftWellLogChannelType>
-    RifReaderPressureDepthData::availableWellLogChannels( const QString& wellName )
+std::set<RifEclipseRftAddress::RftWellLogChannelType> RifReaderPressureDepthData::availableWellLogChannels( const QString& wellName )
 {
     if ( m_pressureDepthDataItems.empty() )
     {

ApplicationLibCode/FileInterface/RifReaderPressureDepthData.h

@@ -44,10 +44,9 @@ public:
     std::vector<QString> labels( const RifEclipseRftAddress& rftAddress );
 
     std::set<RifEclipseRftAddress> eclipseRftAddresses() override;
-    void values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) override;
+    void                           values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) override;
 
-    std::set<QDateTime>
-                        availableTimeSteps( const QString&                                               wellName,
+    std::set<QDateTime> availableTimeSteps( const QString&                                               wellName,
                                             const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels ) override;
     std::set<QDateTime> availableTimeSteps( const QString& wellName ) override;
     std::set<QDateTime> availableTimeSteps( const QString&                                     wellName,

ApplicationLibCode/FileInterface/RifReaderRftInterface.cpp

@@ -20,8 +20,7 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<RifEclipseRftAddress> RifReaderRftInterface::eclipseRftAddresses( const QString&   wellName,
-                                                                           const QDateTime& timeStep )
+std::set<RifEclipseRftAddress> RifReaderRftInterface::eclipseRftAddresses( const QString& wellName, const QDateTime& timeStep )
 {
     std::set<RifEclipseRftAddress> matchingAddresses;
     std::set<RifEclipseRftAddress> allAddresses = this->eclipseRftAddresses();

ApplicationLibCode/FileInterface/RifReaderRftInterface.h

@@ -35,18 +35,16 @@ class RifReaderRftInterface
 {
 public:
     std::set<RifEclipseRftAddress>         eclipseRftAddresses( const QString& wellName, const QDateTime& timeStep );
-    virtual std::set<RifEclipseRftAddress> eclipseRftAddresses()                               = 0;
-    virtual void values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) = 0;
+    virtual std::set<RifEclipseRftAddress> eclipseRftAddresses()                                                         = 0;
+    virtual void                           values( const RifEclipseRftAddress& rftAddress, std::vector<double>* values ) = 0;
 
-    virtual std::set<QDateTime>
-                                availableTimeSteps( const QString&                                               wellName,
-                                                    const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels ) = 0;
-    virtual std::set<QDateTime> availableTimeSteps( const QString& wellName ) = 0;
-    virtual std::set<QDateTime>
-                                                                  availableTimeSteps( const QString&                                     wellName,
+    virtual std::set<QDateTime>                                   availableTimeSteps( const QString&                                               wellName,
+                                                                                      const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels ) = 0;
+    virtual std::set<QDateTime>                                   availableTimeSteps( const QString& wellName ) = 0;
+    virtual std::set<QDateTime>                                   availableTimeSteps( const QString&                                     wellName,
                                                                                       const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName ) = 0;
     virtual std::set<RifEclipseRftAddress::RftWellLogChannelType> availableWellLogChannels( const QString& wellName ) = 0;
-    virtual std::set<QString>                                     wellNames() = 0;
+    virtual std::set<QString>                                     wellNames()                                         = 0;
 
     virtual void cellIndices( const RifEclipseRftAddress& rftAddress, std::vector<caf::VecIjk>* indices );
 };

ApplicationLibCode/FileInterface/RifReaderSettings.cpp

@@ -36,10 +36,7 @@ RifReaderSettings::RifReaderSettings()
     CAF_PDM_InitField( &importNNCs, "importSimulationNNCs", true, "Import NNCs" );
     caf::PdmUiNativeCheckBoxEditor::configureFieldForEditor( &importNNCs );
 
-    CAF_PDM_InitField( &includeInactiveCellsInFaultGeometry,
-                       "includeInactiveCellsInFaultGeometry",
-                       false,
-                       "Include Inactive Cells" );
+    CAF_PDM_InitField( &includeInactiveCellsInFaultGeometry, "includeInactiveCellsInFaultGeometry", false, "Include Inactive Cells" );
     caf::PdmUiNativeCheckBoxEditor::configureFieldForEditor( &includeInactiveCellsInFaultGeometry );
 
     CAF_PDM_InitField( &importAdvancedMswData, "importAdvancedMswData", false, "Import Advanced MSW Data" );

ApplicationLibCode/FileInterface/RifRftSegment.cpp

@@ -207,9 +207,7 @@ const RifRftSegmentData* RifRftSegment::segmentDataByIndex( int segmentIndex ) c
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifRftSegment::createDeviceBranch( int                        deviceBranchFirstSegmentNumber,
-                                        int                        oneBasedBranchIndex,
-                                        const std::vector<double>& seglenstValues )
+void RifRftSegment::createDeviceBranch( int deviceBranchFirstSegmentNumber, int oneBasedBranchIndex, const std::vector<double>& seglenstValues )
 {
     double lastAssignedDeviceBranchDepth = -1.0;
     for ( auto& segData : m_topology )
@@ -343,8 +341,7 @@ std::vector<size_t> RifRftSegment::packerSegmentIndicesOnAnnulus( int branchInde
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<int> RifRftSegment::segmentNumbersForBranchIndex( int                       oneBasedBranchIndex,
-                                                              RiaDefines::RftBranchType branchType ) const
+std::vector<int> RifRftSegment::segmentNumbersForBranchIndex( int oneBasedBranchIndex, RiaDefines::RftBranchType branchType ) const
 {
     std::vector<int> v;
 

ApplicationLibCode/FileInterface/RifRftSegment.h

@@ -52,7 +52,7 @@ public:
     void                           setSegmentData( std::vector<RifRftSegmentData> segmentData );
     std::vector<RifRftSegmentData> topology() const;
 
-    void addResultNameAndSize( const Opm::EclIO::EclFile::EclEntry& resultNameAndSize );
+    void                                       addResultNameAndSize( const Opm::EclIO::EclFile::EclEntry& resultNameAndSize );
     std::vector<Opm::EclIO::EclFile::EclEntry> resultNameAndSize() const;
 
     std::vector<int>   tubingBranchIds() const;
@@ -63,9 +63,7 @@ public:
     const RifRftSegmentData* segmentData( int segmentNumber ) const;
     const RifRftSegmentData* segmentDataByIndex( int segmentIndex ) const;
 
-    void createDeviceBranch( int                        deviceBranchFirstSegmentNumber,
-                             int                        oneBasedBranchIndex,
-                             const std::vector<double>& seglenstValues );
+    void createDeviceBranch( int deviceBranchFirstSegmentNumber, int oneBasedBranchIndex, const std::vector<double>& seglenstValues );
 
     void setBranchLength( int branchId, double length );
     void setBranchType( int branchId, RiaDefines::RftBranchType branchType );

ApplicationLibCode/FileInterface/RifRoffFileTools.cpp

@@ -134,8 +134,7 @@ bool RifRoffFileTools::openGridFile( const QString& fileName, RigEclipseCaseData
         RigActiveCellInfo* activeCellInfo = eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::MATRIX_MODEL );
         CVF_ASSERT( activeCellInfo );
 
-        RigActiveCellInfo* fractureActiveCellInfo =
-            eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
+        RigActiveCellInfo* fractureActiveCellInfo = eclipseCase->activeCellInfo( RiaDefines::PorosityModelType::FRACTURE_MODEL );
         CVF_ASSERT( fractureActiveCellInfo );
 
         RigMainGrid* mainGrid = eclipseCase->mainGrid();
@@ -214,9 +213,8 @@ bool RifRoffFileTools::openGridFile( const QString& fileName, RigEclipseCaseData
                 // Corner coordinates
                 for ( int cIdx = 0; cIdx < 8; ++cIdx )
                 {
-                    double* point =
-                        mainGrid->nodes()[nodeStartIndex + (size_t)gridLocalCellIndex * 8 + cellMappingECLRi[cIdx]].ptr();
-                    auto corner = getCorner( *mainGrid, cornerLines, zCorners, gridLocalCellIndex, cIdx, offset, scale );
+                    double* point  = mainGrid->nodes()[nodeStartIndex + (size_t)gridLocalCellIndex * 8 + cellMappingECLRi[cIdx]].ptr();
+                    auto    corner = getCorner( *mainGrid, cornerLines, zCorners, gridLocalCellIndex, cIdx, offset, scale );
 
                     point[0] = corner.x();
                     point[1] = corner.y();
@@ -356,8 +354,7 @@ cvf::Vec3d RifRoffFileTools::getCorner( const RigMainGrid&        grid,
         kOffset = 1;
     }
 
-    size_t zOffset = ( ( i + iOffset ) * ( ny + 1 ) * ( nz + 1 ) + ( j + jOffset ) * ( nz + 1 ) + ( k + kOffset ) ) * 4 +
-                     adjustedCornerIdx;
+    size_t zOffset = ( ( i + iOffset ) * ( ny + 1 ) * ( nz + 1 ) + ( j + jOffset ) * ( nz + 1 ) + ( k + kOffset ) ) * 4 + adjustedCornerIdx;
 
     double z = -zcorn[zOffset];
     double x = interpolate( top, bottom, z, 0 ) + offset.x();
@@ -484,8 +481,8 @@ size_t RifRoffFileTools::computeActiveCellMatrixIndex( std::vector<int>& activeC
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::pair<bool, std::map<QString, QString>>
-    RifRoffFileTools::createInputProperties( const QString& fileName, RigEclipseCaseData* eclipseCaseData )
+std::pair<bool, std::map<QString, QString>> RifRoffFileTools::createInputProperties( const QString&      fileName,
+                                                                                     RigEclipseCaseData* eclipseCaseData )
 {
     RiaLogging::info( QString( "Reading properties from roff file: %1" ).arg( fileName ) );
 
@@ -529,9 +526,8 @@ std::pair<bool, std::map<QString, QString>>
 
                 if ( !appendNewInputPropertyResult( eclipseCaseData, newResultName, keyword, kind, reader ) )
                 {
-                    RiaLogging::error( QString( "Unable to import result '%1' from %2" )
-                                           .arg( QString::fromStdString( keyword ) )
-                                           .arg( fileName ) );
+                    RiaLogging::error(
+                        QString( "Unable to import result '%1' from %2" ).arg( QString::fromStdString( keyword ) ).arg( fileName ) );
                     return std::make_pair( false, keywordMapping );
                 }
 
@@ -551,12 +547,8 @@ std::pair<bool, std::map<QString, QString>>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RifRoffFileTools::readAndConvertToDouble( int                nx,
-                                                              int                ny,
-                                                              int                nz,
-                                                              const std::string& keyword,
-                                                              roff::Token::Kind  kind,
-                                                              roff::Reader&      reader )
+std::vector<double>
+    RifRoffFileTools::readAndConvertToDouble( int nx, int ny, int nz, const std::string& keyword, roff::Token::Kind kind, roff::Reader& reader )
 {
     std::vector<double> doubleVals;
 
@@ -618,8 +610,7 @@ bool RifRoffFileTools::appendNewInputPropertyResult( RigEclipseCaseData* caseDat
     RigEclipseResultAddress resAddr( RiaDefines::ResultCatType::INPUT_PROPERTY, resultName );
     caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->createResultEntry( resAddr, false );
 
-    auto newPropertyData =
-        caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr );
+    auto newPropertyData = caseData->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->modifiableCellScalarResultTimesteps( resAddr );
 
     newPropertyData->push_back( values );
 

ApplicationLibCode/FileInterface/RifRoffFileTools.h

@@ -51,8 +51,7 @@ public:
 
     static bool openGridFile( const QString& fileName, RigEclipseCaseData* eclipseCase, QString* errorMessages );
 
-    static std::pair<bool, std::map<QString, QString>> createInputProperties( const QString&      fileName,
-                                                                              RigEclipseCaseData* eclipseCase );
+    static std::pair<bool, std::map<QString, QString>> createInputProperties( const QString& fileName, RigEclipseCaseData* eclipseCase );
 
 private:
     static void interpretSplitenzData( int                       nz,

ApplicationLibCode/FileInterface/RifStimPlanModelAsymmetricFrkExporter.cpp

@@ -45,12 +45,7 @@ bool RifStimPlanModelAsymmetricFrkExporter::writeToFile( RimStimPlanModel* stimP
     double barrierDip           = stimPlanModel->barrierDip();
     int    wellPenetrationLayer = stimPlanModel->wellPenetrationLayer();
 
-    appendBarrierDataToStream( stream,
-                               bedDipDeg,
-                               hasBarrier,
-                               RiaEclipseUnitTools::meterToFeet( distanceToBarrier ),
-                               barrierDip,
-                               wellPenetrationLayer );
+    appendBarrierDataToStream( stream, bedDipDeg, hasBarrier, RiaEclipseUnitTools::meterToFeet( distanceToBarrier ), barrierDip, wellPenetrationLayer );
 
     appendFooterToStream( stream );
 

ApplicationLibCode/FileInterface/RifStimPlanModelDeviationFrkExporter.cpp

@@ -54,13 +54,7 @@ bool RifStimPlanModelDeviationFrkExporter::writeToFile( RimStimPlanModel* stimPl
     std::vector<double> yValues;
     std::vector<double> tvdValues;
     std::vector<double> mdValues;
-    RigWellPathGeometryExporter::computeWellPathDataForExport( wellPath,
-                                                               mdStepSize,
-                                                               xValues,
-                                                               yValues,
-                                                               tvdValues,
-                                                               mdValues,
-                                                               showTextMdRkb );
+    RigWellPathGeometryExporter::computeWellPathDataForExport( wellPath, mdStepSize, xValues, yValues, tvdValues, mdValues, showTextMdRkb );
     convertFromMeterToFeet( mdValues );
     convertFromMeterToFeet( tvdValues );
 
@@ -87,9 +81,7 @@ void RifStimPlanModelDeviationFrkExporter::appendHeaderToStream( QTextStream& st
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifStimPlanModelDeviationFrkExporter::appendToStream( QTextStream&               stream,
-                                                           const QString&             label,
-                                                           const std::vector<double>& values )
+void RifStimPlanModelDeviationFrkExporter::appendToStream( QTextStream& stream, const QString& label, const std::vector<double>& values )
 {
     stream.setRealNumberPrecision( 20 );
     stream << "<cNamedSet>" << '\n'

ApplicationLibCode/FileInterface/RifStimPlanModelExporter.cpp

@@ -28,13 +28,9 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifStimPlanModelExporter::writeToDirectory( RimStimPlanModel* stimPlanModel,
-                                                 bool              useDetailedFluidLoss,
-                                                 const QString&    directoryPath )
+bool RifStimPlanModelExporter::writeToDirectory( RimStimPlanModel* stimPlanModel, bool useDetailedFluidLoss, const QString& directoryPath )
 {
-    return RifStimPlanModelGeologicalFrkExporter::writeToFile( stimPlanModel,
-                                                               useDetailedFluidLoss,
-                                                               directoryPath + "/Geological.frk" ) &&
+    return RifStimPlanModelGeologicalFrkExporter::writeToFile( stimPlanModel, useDetailedFluidLoss, directoryPath + "/Geological.frk" ) &&
            RifStimPlanModelDeviationFrkExporter::writeToFile( stimPlanModel, directoryPath + "/Deviation.frk" ) &&
            RifStimPlanModelPerfsFrkExporter::writeToFile( stimPlanModel, directoryPath + "/Perfs.frk" ) &&
            RifStimPlanModelAsymmetricFrkExporter::writeToFile( stimPlanModel, directoryPath + "/Asymmetric.frk" );

ApplicationLibCode/FileInterface/RifStimPlanModelGeologicalFrkExporter.cpp

@@ -38,9 +38,7 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RifStimPlanModelGeologicalFrkExporter::writeToFile( RimStimPlanModel* stimPlanModel,
-                                                         bool              useDetailedLoss,
-                                                         const QString&    filepath )
+bool RifStimPlanModelGeologicalFrkExporter::writeToFile( RimStimPlanModel* stimPlanModel, bool useDetailedLoss, const QString& filepath )
 {
     std::vector<QString> labels;
     // TVD depth of top of zone (ft)
@@ -105,10 +103,9 @@ bool RifStimPlanModelGeologicalFrkExporter::writeToFile( RimStimPlanModel* stimP
     // Warn if the generated model has too many layers for StimPlan
     if ( tvd.size() > MAX_STIMPLAN_LAYERS )
     {
-        RiaLogging::warning(
-            QString( "Exporting model with too many layers: %1. Maximum supported number of layers is %2." )
-                .arg( tvd.size() )
-                .arg( MAX_STIMPLAN_LAYERS ) );
+        RiaLogging::warning( QString( "Exporting model with too many layers: %1. Maximum supported number of layers is %2." )
+                                 .arg( tvd.size() )
+                                 .arg( MAX_STIMPLAN_LAYERS ) );
     }
 
     // Make sure stress gradients are in the valid interval
@@ -170,8 +167,7 @@ bool RifStimPlanModelGeologicalFrkExporter::writeToFile( RimStimPlanModel* stimP
     for ( const QString& label : labels )
         csvLabels.push_back( label );
 
-    return writeToFrkFile( filepath, labels, values ) &&
-           writeToCsvFile( filepath, csvLabels, values, faciesNames, formationNames );
+    return writeToFrkFile( filepath, labels, values ) && writeToCsvFile( filepath, csvLabels, values, faciesNames, formationNames );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -212,7 +208,7 @@ bool RifStimPlanModelGeologicalFrkExporter::writeToCsvFile( const QString&
                                                             const std::vector<QString>&                   labels,
                                                             const std::map<QString, std::vector<double>>& values,
                                                             const std::vector<QString>&                   faciesNames,
-                                                            const std::vector<QString>& formationNames )
+                                                            const std::vector<QString>&                   formationNames )
 {
     // Create the csv in the same directory as the frk file
     QFileInfo fi( filepath );
@@ -281,9 +277,7 @@ void RifStimPlanModelGeologicalFrkExporter::appendHeaderToStream( QTextStream& s
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifStimPlanModelGeologicalFrkExporter::appendToStream( QTextStream&               stream,
-                                                            const QString&             label,
-                                                            const std::vector<double>& values )
+void RifStimPlanModelGeologicalFrkExporter::appendToStream( QTextStream& stream, const QString& label, const std::vector<double>& values )
 {
     stream << "<cNamedSet>" << caf::endl
            << "<name>" << caf::endl
@@ -324,12 +318,11 @@ void RifStimPlanModelGeologicalFrkExporter::fixupStressGradients( std::vector<do
     {
         if ( stressGradients[i] < minStressGradient || stressGradients[i] > maxStressGradient )
         {
-            RiaLogging::warning(
-                QString( "Found stress gradient outside valid range [%1, %2]. Replacing %3 with default value: %4." )
-                    .arg( minStressGradient )
-                    .arg( maxStressGradient )
-                    .arg( stressGradients[i] )
-                    .arg( defaultStressGradient ) );
+            RiaLogging::warning( QString( "Found stress gradient outside valid range [%1, %2]. Replacing %3 with default value: %4." )
+                                     .arg( minStressGradient )
+                                     .arg( maxStressGradient )
+                                     .arg( stressGradients[i] )
+                                     .arg( defaultStressGradient ) );
 
             stressGradients[i] = defaultStressGradient;
         }
@@ -339,19 +332,16 @@ void RifStimPlanModelGeologicalFrkExporter::fixupStressGradients( std::vector<do
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifStimPlanModelGeologicalFrkExporter::fixupLowerBoundary( std::vector<double>& values,
-                                                                double               minValue,
-                                                                const QString&       property )
+void RifStimPlanModelGeologicalFrkExporter::fixupLowerBoundary( std::vector<double>& values, double minValue, const QString& property )
 {
     for ( double& value : values )
     {
         if ( value < minValue )
         {
-            RiaLogging::warning(
-                QString( "Found %1 outside valid lower boundary (%2). Replacing %3 with default value: %2." )
-                    .arg( property )
-                    .arg( minValue )
-                    .arg( value ) );
+            RiaLogging::warning( QString( "Found %1 outside valid lower boundary (%2). Replacing %3 with default value: %2." )
+                                     .arg( property )
+                                     .arg( minValue )
+                                     .arg( value ) );
             value = minValue;
         }
     }
@@ -387,8 +377,7 @@ bool RifStimPlanModelGeologicalFrkExporter::hasInvalidData( const std::vector<do
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::pair<std::vector<double>, std::vector<double>>
-    RifStimPlanModelGeologicalFrkExporter::createDepthRanges( const std::vector<double>& tvd )
+std::pair<std::vector<double>, std::vector<double>> RifStimPlanModelGeologicalFrkExporter::createDepthRanges( const std::vector<double>& tvd )
 {
     std::vector<double> startTvd;
     std::vector<double> endTvd;
@@ -411,8 +400,8 @@ std::pair<std::vector<double>, std::vector<double>>
 //--------------------------------------------------------------------------------------------------
 std::vector<double> RifStimPlanModelGeologicalFrkExporter::createPerforationValues( const std::vector<double>& depthStart,
                                                                                     const std::vector<double>& depthEnd,
-                                                                                    double perforationTop,
-                                                                                    double perforationBottom )
+                                                                                    double                     perforationTop,
+                                                                                    double                     perforationBottom )
 {
     std::vector<double> perfs;
     for ( size_t idx = 0; idx < depthStart.size(); idx++ )

ApplicationLibCode/FileInterface/RifStimPlanModelGeologicalFrkExporter.h

@@ -39,9 +39,8 @@ public:
     static bool writeToFile( RimStimPlanModel* plot, bool useDetailedFluidLoss, const QString& filepath );
 
 private:
-    static bool writeToFrkFile( const QString&                                filepath,
-                                const std::vector<QString>&                   labels,
-                                const std::map<QString, std::vector<double>>& values );
+    static bool
+                writeToFrkFile( const QString& filepath, const std::vector<QString>& labels, const std::map<QString, std::vector<double>>& values );
     static bool writeToCsvFile( const QString&                                filepath,
                                 const std::vector<QString>&                   labels,
                                 const std::map<QString, std::vector<double>>& values,

ApplicationLibCode/FileInterface/RifStimPlanModelPerfsFrkExporter.cpp

@@ -54,18 +54,14 @@ bool RifStimPlanModelPerfsFrkExporter::writeToFile( RimStimPlanModel* stimPlanMo
     QTextStream stream( &data );
     appendHeaderToStream( stream );
 
-    bool isTransverse =
-        ( stimPlanModel->fractureOrientation() == RimStimPlanModel::FractureOrientation::TRANSVERSE_WELL_PATH ||
-          stimPlanModel->fractureOrientation() == RimStimPlanModel::FractureOrientation::AZIMUTH );
+    bool isTransverse = ( stimPlanModel->fractureOrientation() == RimStimPlanModel::FractureOrientation::TRANSVERSE_WELL_PATH ||
+                          stimPlanModel->fractureOrientation() == RimStimPlanModel::FractureOrientation::AZIMUTH );
 
     appendFractureOrientationToStream( stream, isTransverse );
 
     // Unit: meter
     auto [topMD, bottomMD] = calculateTopAndBottomMeasuredDepth( stimPlanModel, wellPath );
-    appendPerforationToStream( stream,
-                               1,
-                               RiaEclipseUnitTools::meterToFeet( topMD ),
-                               RiaEclipseUnitTools::meterToFeet( bottomMD ) );
+    appendPerforationToStream( stream, 1, RiaEclipseUnitTools::meterToFeet( topMD ), RiaEclipseUnitTools::meterToFeet( bottomMD ) );
 
     appendFooterToStream( stream );
 
@@ -114,8 +110,7 @@ void RifStimPlanModelPerfsFrkExporter::appendFooterToStream( QTextStream& stream
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RifStimPlanModelPerfsFrkExporter::computeMeasuredDepthForPosition( const RimWellPath* wellPath,
-                                                                          const cvf::Vec3d&  position )
+double RifStimPlanModelPerfsFrkExporter::computeMeasuredDepthForPosition( const RimWellPath* wellPath, const cvf::Vec3d& position )
 {
     const RigWellPath* wellPathGeometry = wellPath->wellPathGeometry();
 
@@ -159,9 +154,8 @@ double RifStimPlanModelPerfsFrkExporter::computeMeasuredDepthForPosition( const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::pair<double, double>
-    RifStimPlanModelPerfsFrkExporter::calculateTopAndBottomMeasuredDepth( RimStimPlanModel* stimPlanModel,
-                                                                          RimWellPath*      wellPath )
+std::pair<double, double> RifStimPlanModelPerfsFrkExporter::calculateTopAndBottomMeasuredDepth( RimStimPlanModel* stimPlanModel,
+                                                                                                RimWellPath*      wellPath )
 {
     double perforationLength = stimPlanModel->perforationLength();
 

ApplicationLibCode/FileInterface/RifStimPlanModelPerfsFrkExporter.h

@@ -36,8 +36,7 @@ class RifStimPlanModelPerfsFrkExporter
 public:
     static bool writeToFile( RimStimPlanModel* stimPlanModel, const QString& filepath );
 
-    static std::pair<double, double> calculateTopAndBottomMeasuredDepth( RimStimPlanModel* stimPlanModel,
-                                                                         RimWellPath*      wellPath );
+    static std::pair<double, double> calculateTopAndBottomMeasuredDepth( RimStimPlanModel* stimPlanModel, RimWellPath* wellPath );
 
     static double computeMeasuredDepthForPosition( const RimWellPath* wellPath, const cvf::Vec3d& position );
 

ApplicationLibCode/FileInterface/RifStimPlanXmlReader.cpp

@@ -40,11 +40,11 @@ RigStimPlanFractureDefinition::Orientation mapTextToOrientation( const QString t
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-cvf::ref<RigStimPlanFractureDefinition> RifStimPlanXmlReader::readStimPlanXMLFile( const QString& stimPlanFileName,
-                                                                                   double     conductivityScalingFactor,
-                                                                                   MirrorMode mirrorMode,
+cvf::ref<RigStimPlanFractureDefinition> RifStimPlanXmlReader::readStimPlanXMLFile( const QString&                stimPlanFileName,
+                                                                                   double                        conductivityScalingFactor,
+                                                                                   MirrorMode                    mirrorMode,
                                                                                    RiaDefines::EclipseUnitSystem requiredUnit,
-                                                                                   QString* errorMessage )
+                                                                                   QString*                      errorMessage )
 {
     RiaLogging::info( QString( "Starting to open StimPlan XML file: '%1'" ).arg( stimPlanFileName ) );
 
@@ -65,9 +65,8 @@ cvf::ref<RigStimPlanFractureDefinition> RifStimPlanXmlReader::readStimPlanXMLFil
         caf::AppEnum<RiaDefines::EclipseUnitSystem> unitSystem = stimPlanFileData->unitSet();
 
         if ( unitSystem != RiaDefines::EclipseUnitSystem::UNITS_UNKNOWN )
-            RiaLogging::info( QString( "Setting unit system for StimPlan fracture template %1 to %2" )
-                                  .arg( stimPlanFileName )
-                                  .arg( unitSystem.uiText() ) );
+            RiaLogging::info(
+                QString( "Setting unit system for StimPlan fracture template %1 to %2" ).arg( stimPlanFileName ).arg( unitSystem.uiText() ) );
         else
             RiaLogging::error( QString( "Found invalid units for %1. Unit system not set." ).arg( stimPlanFileName ) );
 
@@ -80,8 +79,8 @@ cvf::ref<RigStimPlanFractureDefinition> RifStimPlanXmlReader::readStimPlanXMLFil
     }
 
     size_t numberOfYValues = stimPlanFileData->yCount();
-    RiaLogging::debug( QString( "Grid size X: %1, Y: %2" )
-                           .arg( QString::number( stimPlanFileData->xCount() ), QString::number( numberOfYValues ) ) );
+    RiaLogging::debug(
+        QString( "Grid size X: %1, Y: %2" ).arg( QString::number( stimPlanFileData->xCount() ), QString::number( numberOfYValues ) ) );
 
     size_t numberOfTimeSteps = stimPlanFileData->timeSteps().size();
     RiaLogging::debug( QString( "Number of time-steps: %1" ).arg( numberOfTimeSteps ) );
@@ -129,8 +128,7 @@ cvf::ref<RigStimPlanFractureDefinition> RifStimPlanXmlReader::readStimPlanXMLFil
                 bool valuesOK = stimPlanFileData->numberOfParameterValuesOK( propertyValuesAtTimestep );
                 if ( !valuesOK )
                 {
-                    RiaLogging::error(
-                        QString( "Inconsistency detected in reading XML file: '%1'" ).arg( dataFile.fileName() ) );
+                    RiaLogging::error( QString( "Inconsistency detected in reading XML file: '%1'" ).arg( dataFile.fileName() ) );
                     return nullptr;
                 }
 
@@ -226,14 +224,12 @@ void RifStimPlanXmlReader::readStimplanGridAndTimesteps( QXmlStreamReader&
                     double tvdToTopPerfFt = getAttributeValueDouble( xmlStream, "TVDToTopPerfFt" );
                     double tvdToBotPerfFt = getAttributeValueDouble( xmlStream, "TVDToBottomPerfFt" );
 
-                    tvdToTopPerf =
-                        RifStimPlanXmlReader::valueInRequiredUnitSystem( RiaDefines::EclipseUnitSystem::UNITS_FIELD,
-                                                                         destinationUnit,
-                                                                         tvdToTopPerfFt );
-                    tvdToBotPerf =
-                        RifStimPlanXmlReader::valueInRequiredUnitSystem( RiaDefines::EclipseUnitSystem::UNITS_FIELD,
-                                                                         destinationUnit,
-                                                                         tvdToBotPerfFt );
+                    tvdToTopPerf = RifStimPlanXmlReader::valueInRequiredUnitSystem( RiaDefines::EclipseUnitSystem::UNITS_FIELD,
+                                                                                    destinationUnit,
+                                                                                    tvdToTopPerfFt );
+                    tvdToBotPerf = RifStimPlanXmlReader::valueInRequiredUnitSystem( RiaDefines::EclipseUnitSystem::UNITS_FIELD,
+                                                                                    destinationUnit,
+                                                                                    tvdToBotPerfFt );
                 }
 
                 gridSectionCount++;
@@ -281,15 +277,13 @@ void RifStimPlanXmlReader::readStimplanGridAndTimesteps( QXmlStreamReader&
                     std::vector<double> gridValues;
                     getGriddingValues( xmlStream, gridValues, dummy );
 
-                    gridValuesXs = RifStimPlanXmlReader::valuesInRequiredUnitSystem( stimPlanFileData->m_unitSet,
-                                                                                     destinationUnit,
-                                                                                     gridValues );
+                    gridValuesXs = RifStimPlanXmlReader::valuesInRequiredUnitSystem( stimPlanFileData->m_unitSet, destinationUnit, gridValues );
                 }
 
                 stimPlanFileData->m_fileXs = gridValuesXs;
 
-                stimPlanFileData->generateXsFromFileXs(
-                    mirrorMode == MirrorMode::MIRROR_AUTO ? !hasNegativeValues( gridValuesXs ) : (bool)mirrorMode );
+                stimPlanFileData->generateXsFromFileXs( mirrorMode == MirrorMode::MIRROR_AUTO ? !hasNegativeValues( gridValuesXs )
+                                                                                              : (bool)mirrorMode );
             }
             else if ( xmlStream.name() == "ys" )
             {
@@ -298,9 +292,7 @@ void RifStimPlanXmlReader::readStimplanGridAndTimesteps( QXmlStreamReader&
                     std::vector<double> gridValues;
                     getGriddingValues( xmlStream, gridValues, startNegValuesYs );
 
-                    gridValuesYs = RifStimPlanXmlReader::valuesInRequiredUnitSystem( stimPlanFileData->m_unitSet,
-                                                                                     destinationUnit,
-                                                                                     gridValues );
+                    gridValuesYs = RifStimPlanXmlReader::valuesInRequiredUnitSystem( stimPlanFileData->m_unitSet, destinationUnit, gridValues );
                 }
 
                 // Reorder and change sign
@@ -411,8 +403,7 @@ std::vector<double> RifStimPlanXmlReader::valuesInRequiredUnitSystem( RiaDefines
                                                                       RiaDefines::EclipseUnitSystem requiredUnit,
                                                                       const std::vector<double>&    values )
 {
-    if ( sourceUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD &&
-         requiredUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
+    if ( sourceUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD && requiredUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
     {
         std::vector<double> convertedValues;
         for ( const auto& valueInFeet : values )
@@ -422,8 +413,7 @@ std::vector<double> RifStimPlanXmlReader::valuesInRequiredUnitSystem( RiaDefines
 
         return convertedValues;
     }
-    else if ( sourceUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC &&
-              requiredUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
+    else if ( sourceUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC && requiredUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
     {
         std::vector<double> convertedValues;
         for ( const auto& valueInMeter : values )
@@ -444,13 +434,11 @@ double RifStimPlanXmlReader::valueInRequiredUnitSystem( RiaDefines::EclipseUnitS
                                                         RiaDefines::EclipseUnitSystem requiredUnit,
                                                         double                        value )
 {
-    if ( sourceUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD &&
-         requiredUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
+    if ( sourceUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD && requiredUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC )
     {
         return RiaEclipseUnitTools::feetToMeter( value );
     }
-    else if ( sourceUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC &&
-              requiredUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
+    else if ( sourceUnit == RiaDefines::EclipseUnitSystem::UNITS_METRIC && requiredUnit == RiaDefines::EclipseUnitSystem::UNITS_FIELD )
     {
         return RiaEclipseUnitTools::meterToFeet( value );
     }
@@ -469,9 +457,7 @@ bool RifStimPlanXmlReader::isTextEqual( const QStringRef& text, const QString& c
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifStimPlanXmlReader::getGriddingValues( QXmlStreamReader&    xmlStream,
-                                              std::vector<double>& gridValues,
-                                              size_t&              startNegValues )
+void RifStimPlanXmlReader::getGriddingValues( QXmlStreamReader& xmlStream, std::vector<double>& gridValues, size_t& startNegValues )
 {
     QString gridValuesString = xmlStream.readElementText().replace( '\n', ' ' );
     gridValuesString         = gridValuesString.replace( '[', ' ' ).replace( ']', ' ' );

ApplicationLibCode/FileInterface/RifStimPlanXmlReader.h

@@ -40,9 +40,9 @@ public:
         MIRROR_AUTO = 2
     };
 
-    static cvf::ref<RigStimPlanFractureDefinition> readStimPlanXMLFile( const QString& stimPlanFileName,
-                                                                        double         conductivityScalingFactor,
-                                                                        MirrorMode     mirrorMode,
+    static cvf::ref<RigStimPlanFractureDefinition> readStimPlanXMLFile( const QString&                stimPlanFileName,
+                                                                        double                        conductivityScalingFactor,
+                                                                        MirrorMode                    mirrorMode,
                                                                         RiaDefines::EclipseUnitSystem requiredUnit,
                                                                         QString*                      errorMessage );
 
@@ -54,7 +54,7 @@ private:
 
     static double  getAttributeValueDouble( QXmlStreamReader& xmlStream, const QString& parameterName );
     static QString getAttributeValueString( QXmlStreamReader& xmlStream, const QString& parameterName );
-    static void getGriddingValues( QXmlStreamReader& xmlStream, std::vector<double>& gridValues, size_t& startNegValues );
+    static void    getGriddingValues( QXmlStreamReader& xmlStream, std::vector<double>& gridValues, size_t& startNegValues );
 
     static std::vector<std::vector<double>> getAllDepthDataAtTimeStep( QXmlStreamReader& xmlStream );
 
@@ -62,9 +62,8 @@ private:
                                                            RiaDefines::EclipseUnitSystem requiredUnit,
                                                            const std::vector<double>&    values );
 
-    static double valueInRequiredUnitSystem( RiaDefines::EclipseUnitSystem sourceUnit,
-                                             RiaDefines::EclipseUnitSystem requiredUnit,
-                                             double                        value );
+    static double
+        valueInRequiredUnitSystem( RiaDefines::EclipseUnitSystem sourceUnit, RiaDefines::EclipseUnitSystem requiredUnit, double value );
 
     static bool isTextEqual( const QStringRef& text, const QString& compareText );
 };

ApplicationLibCode/FileInterface/RifSummaryCaseRestartSelector.cpp

@@ -189,17 +189,16 @@ void RifSummaryCaseRestartSelector::determineFilesToImportByAskingUser( const st
     caf::ProgressInfo progress( initialFiles.size(), QString( "Importing files" ) );
     for ( const RifSummaryCaseFileImportInfo& initialFile : initialFiles )
     {
-        RicSummaryCaseRestartDialogResult result =
-            RicSummaryCaseRestartDialog::openDialog( initialFile.summaryFileName(),
-                                                     initialFile.gridFileName(),
-                                                     initialFile.failOnSummaryFileError(),
-                                                     enableApplyToAllField,
-                                                     m_ensembleOrGroupMode,
-                                                     defaultSummaryImportMode,
-                                                     defaultGridImportMode,
-                                                     m_ensembleOrGroupMode,
-                                                     &lastResult,
-                                                     nullptr );
+        RicSummaryCaseRestartDialogResult result = RicSummaryCaseRestartDialog::openDialog( initialFile.summaryFileName(),
+                                                                                            initialFile.gridFileName(),
+                                                                                            initialFile.failOnSummaryFileError(),
+                                                                                            enableApplyToAllField,
+                                                                                            m_ensembleOrGroupMode,
+                                                                                            defaultSummaryImportMode,
+                                                                                            defaultGridImportMode,
+                                                                                            m_ensembleOrGroupMode,
+                                                                                            &lastResult,
+                                                                                            nullptr );
 
         if ( result.status == RicSummaryCaseRestartDialogResult::SUMMARY_CANCELLED )
         {
@@ -290,12 +289,10 @@ void RifSummaryCaseRestartSelector::determineFilesToImportUsingPrefs( const std:
                 m_summaryFileInfos.push_back( RifSummaryCaseFileResultInfo( initialSummaryFile, false ) );
 
                 std::vector<QString>            warnings;
-                std::vector<RifRestartFileInfo> restartFileInfos =
-                    RifEclipseSummaryTools::getRestartFiles( initialSummaryFile, warnings );
+                std::vector<RifRestartFileInfo> restartFileInfos = RifEclipseSummaryTools::getRestartFiles( initialSummaryFile, warnings );
                 for ( const auto& rfi : restartFileInfos )
                 {
-                    RifSummaryCaseFileResultInfo resultFileInfo( RiaFilePathTools::toInternalSeparator( rfi.fileName ),
-                                                                 false );
+                    RifSummaryCaseFileResultInfo resultFileInfo( RiaFilePathTools::toInternalSeparator( rfi.fileName ), false );
                     if ( !vectorContains( m_summaryFileInfos, resultFileInfo ) )
                     {
                         m_summaryFileInfos.push_back( resultFileInfo );
@@ -313,8 +310,7 @@ void RifSummaryCaseRestartSelector::determineFilesToImportUsingPrefs( const std:
             {
                 std::vector<QString> warnings;
 
-                std::vector<RifRestartFileInfo> restartFileInfos =
-                    RifEclipseSummaryTools::getRestartFiles( initialSummaryFile, warnings );
+                std::vector<RifRestartFileInfo> restartFileInfos = RifEclipseSummaryTools::getRestartFiles( initialSummaryFile, warnings );
                 for ( const auto& rfi : restartFileInfos )
                 {
                     QString gridFileName = RifEclipseSummaryTools::findGridCaseFileFromSummaryHeaderFile( rfi.fileName );

ApplicationLibCode/FileInterface/RifSummaryCaseRestartSelector.h

@@ -53,8 +53,7 @@ public:
 
 private:
     void determineFilesToImport( const std::vector<RifSummaryCaseFileImportInfo>& initialFiles );
-    void determineFilesToImportByAskingUser( const std::vector<RifSummaryCaseFileImportInfo>& initialFiles,
-                                             bool                                             enableApplyToAllField );
+    void determineFilesToImportByAskingUser( const std::vector<RifSummaryCaseFileImportInfo>& initialFiles, bool enableApplyToAllField );
     void determineFilesToImportUsingPrefs( const std::vector<RifSummaryCaseFileImportInfo>& initialFiles );
 
     bool m_showDialog;

ApplicationLibCode/FileInterface/RifSummaryReaderMultipleFiles.h

@@ -39,9 +39,9 @@ public:
 
     bool createReadersAndImportMetaData( RiaThreadSafeLogger* threadSafeLogger );
 
-    std::vector<time_t> timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
-    bool        values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
-    std::string unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
+    std::vector<time_t>           timeSteps( const RifEclipseSummaryAddress& resultAddress ) const override;
+    bool                          values( const RifEclipseSummaryAddress& resultAddress, std::vector<double>* values ) const override;
+    std::string                   unitName( const RifEclipseSummaryAddress& resultAddress ) const override;
     RiaDefines::EclipseUnitSystem unitSystem() const override;
 
 private:

ApplicationLibCode/FileInterface/RifSurfaceImporter.cpp

@@ -134,8 +134,7 @@ void RifSurfaceImporter::readGocadFile( const QString& filename, RigGocadData* g
                             for ( size_t i = 0; i < propertyNames.size(); i++ )
                             {
                                 auto tokenIndex = 5 + i;
-                                if ( tokenIndex < tokens.size() )
-                                    RiaStdStringTools::toDouble( tokens[tokenIndex], value );
+                                if ( tokenIndex < tokens.size() ) RiaStdStringTools::toDouble( tokens[tokenIndex], value );
 
                                 propertyValues[i].push_back( static_cast<float>( value ) );
                             }
@@ -335,8 +334,8 @@ std::pair<std::vector<cvf::Vec3d>, std::vector<unsigned>> RifSurfaceImporter::re
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::pair<std::vector<cvf::Vec3d>, std::vector<unsigned>>
-    RifSurfaceImporter::readOpenWorksXyzFile( const QString& filename, double preferredPointDistance )
+std::pair<std::vector<cvf::Vec3d>, std::vector<unsigned>> RifSurfaceImporter::readOpenWorksXyzFile( const QString& filename,
+                                                                                                    double         preferredPointDistance )
 {
     size_t estimatedPointCount = 0;
     {
@@ -376,14 +375,12 @@ std::pair<std::vector<cvf::Vec3d>, std::vector<unsigned>>
 
     // Checks if the given vector is a possible new candidate for an axis vector and adds it to the given list
     // of axesVectorCandidates. Also increases the number of occurrences of vector candidates.
-    auto maybeInsertAxisVectorCandidate =
-        [epsilon]( const cvf::Vec2d                              vector,
-                   std::map<cvf::Vec2d, double, vec2dCompare>&   axesVectorCandidates,
-                   std::map<cvf::Vec2d, unsigned, vec2dCompare>& axesVectorCandidatesNum ) -> bool {
+    auto maybeInsertAxisVectorCandidate = [epsilon]( const cvf::Vec2d                              vector,
+                                                     std::map<cvf::Vec2d, double, vec2dCompare>&   axesVectorCandidates,
+                                                     std::map<cvf::Vec2d, unsigned, vec2dCompare>& axesVectorCandidatesNum ) -> bool {
         double     length           = vector.length();
         cvf::Vec2d normalizedVector = vector.getNormalized();
-        for ( std::map<cvf::Vec2d, double, vec2dCompare>::iterator iter = axesVectorCandidates.begin();
-              iter != axesVectorCandidates.end();
+        for ( std::map<cvf::Vec2d, double, vec2dCompare>::iterator iter = axesVectorCandidates.begin(); iter != axesVectorCandidates.end();
               ++iter )
         {
             if ( vectorFuzzyCompare( iter->first, normalizedVector, 0.1 ) )
@@ -451,9 +448,7 @@ std::pair<std::vector<cvf::Vec3d>, std::vector<unsigned>>
                 if ( surfacePoints.size() > 1 )
                 {
                     cvf::Vec3d pointToPointVector = surfacePoints.back() - surfacePoints[surfacePoints.size() - 2];
-                    maybeInsertAxisVectorCandidate( to2d( pointToPointVector ),
-                                                    axesVectorCandidates,
-                                                    axesVectorCandidatesNum );
+                    maybeInsertAxisVectorCandidate( to2d( pointToPointVector ), axesVectorCandidates, axesVectorCandidatesNum );
                 }
             }
             else // Probably a comment line, skip
@@ -495,13 +490,9 @@ std::pair<std::vector<cvf::Vec3d>, std::vector<unsigned>>
                                                                                    const cvf::Vec2d linePoint2,
                                                                                    const cvf::Vec2d point ) -> int {
         double     normalizedIntersection = 0.0;
-        cvf::Vec2d projectedPoint         = to2d( cvf::GeometryTools::projectPointOnLine( to3d( linePoint1 ),
-                                                                                  to3d( linePoint2 ),
-                                                                                  to3d( point ),
-                                                                                  &normalizedIntersection ) );
-        if ( vectorFuzzyCompare( ( projectedPoint - to2d( surfacePoints[0] ) ).getNormalized(),
-                                 primaryAxisVector.getNormalized(),
-                                 epsilon ) )
+        cvf::Vec2d projectedPoint =
+            to2d( cvf::GeometryTools::projectPointOnLine( to3d( linePoint1 ), to3d( linePoint2 ), to3d( point ), &normalizedIntersection ) );
+        if ( vectorFuzzyCompare( ( projectedPoint - to2d( surfacePoints[0] ) ).getNormalized(), primaryAxisVector.getNormalized(), epsilon ) )
             return static_cast<int>( ( projectedPoint - to2d( surfacePoints[0] ) ).length() / primaryAxisVector.length() );
         else
             return static_cast<int>( -( projectedPoint - to2d( surfacePoints[0] ) ).length() / primaryAxisVector.length() );
@@ -653,6 +644,5 @@ bool RifSurfaceImporter::vectorFuzzyCompare( const cvf::Vec2d& vector1, const cv
         if ( diff <= largest * maxRelDiff ) return true;
         return false;
     };
-    return ( AlmostEqualRelativeAndAbs( vector1.x(), vector2.x(), epsilon ) &&
-             AlmostEqualRelativeAndAbs( vector1.y(), vector2.y(), epsilon ) );
+    return ( AlmostEqualRelativeAndAbs( vector1.x(), vector2.x(), epsilon ) && AlmostEqualRelativeAndAbs( vector1.y(), vector2.y(), epsilon ) );
 }

ApplicationLibCode/FileInterface/RifSurfaceImporter.h

@@ -31,10 +31,10 @@ class RigGocadData;
 class RifSurfaceImporter
 {
 public:
-    static void readGocadFile( const QString& filename, RigGocadData* gocadData );
+    static void                                                      readGocadFile( const QString& filename, RigGocadData* gocadData );
     static std::pair<std::vector<cvf::Vec3d>, std::vector<unsigned>> readPetrelFile( const QString& filename );
-    static std::pair<std::vector<cvf::Vec3d>, std::vector<unsigned>>
-        readOpenWorksXyzFile( const QString& filename, double preferredPointDistance );
+    static std::pair<std::vector<cvf::Vec3d>, std::vector<unsigned>> readOpenWorksXyzFile( const QString& filename,
+                                                                                           double         preferredPointDistance );
 
 private:
     static bool generateTriangleIndices( const std::vector<std::vector<unsigned>>& indexToPointData,
@@ -42,7 +42,6 @@ private:
                                          const size_t&                             j,
                                          std::vector<unsigned>&                    triangleIndices,
                                          unsigned                                  resolution = 1 );
-    static bool vectorFuzzyCompare( const cvf::Vec2d& vector1,
-                                    const cvf::Vec2d& vector2,
-                                    double            epsilon = std::numeric_limits<double>::epsilon() );
+    static bool
+        vectorFuzzyCompare( const cvf::Vec2d& vector1, const cvf::Vec2d& vector2, double epsilon = std::numeric_limits<double>::epsilon() );
 };

ApplicationLibCode/FileInterface/RifThermalFractureReader.cpp

@@ -37,8 +37,7 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::pair<std::shared_ptr<RigThermalFractureDefinition>, QString>
-    RifThermalFractureReader::readFractureCsvFile( const QString& filePath )
+std::pair<std::shared_ptr<RigThermalFractureDefinition>, QString> RifThermalFractureReader::readFractureCsvFile( const QString& filePath )
 {
     QFile file( filePath );
     if ( !file.open( QIODevice::ReadOnly | QIODevice::Text ) )
@@ -50,27 +49,26 @@ std::pair<std::shared_ptr<RigThermalFractureDefinition>, QString>
 
     QString separator = ",";
 
-    auto appendPropertyValues =
-        [definition]( int nodeIndex, int valueOffset, const QStringList& values, double conductivityFactor ) {
-            CAF_ASSERT( valueOffset <= values.size() );
-            for ( int i = valueOffset; i < values.size(); i++ )
+    auto appendPropertyValues = [definition]( int nodeIndex, int valueOffset, const QStringList& values, double conductivityFactor ) {
+        CAF_ASSERT( valueOffset <= values.size() );
+        for ( int i = valueOffset; i < values.size(); i++ )
+        {
+            bool   isOk  = false;
+            double value = values[i].toDouble( &isOk );
+            if ( isOk )
             {
-                bool   isOk  = false;
-                double value = values[i].toDouble( &isOk );
-                if ( isOk )
+                int propertyIndex = i - valueOffset;
+
+                // Convert conductivity from Darcy to milliDarcy
+                if ( definition->getPropertyIndex( "Conductivity" ) == propertyIndex )
                 {
-                    int propertyIndex = i - valueOffset;
-
-                    // Convert conductivity from Darcy to milliDarcy
-                    if ( definition->getPropertyIndex( "Conductivity" ) == propertyIndex )
-                    {
-                        value *= conductivityFactor;
-                    }
-
-                    definition->appendPropertyValue( propertyIndex, nodeIndex, value );
+                    value *= conductivityFactor;
                 }
+
+                definition->appendPropertyValue( propertyIndex, nodeIndex, value );
             }
-        };
+        }
+    };
 
     QTextStream in( &file );
     int         lineNumber = 1;
@@ -219,9 +217,8 @@ bool RifThermalFractureReader::isPerimeterNodeLine( const QString& line )
 {
     std::vector<QString> validPerimeterNames = { "Perimeter Node", "Bottom Node", "Top Node", "Right Node", "Left Node" };
 
-    bool result = std::any_of( validPerimeterNames.begin(), validPerimeterNames.end(), [line]( const QString& str ) {
-        return line.contains( str );
-    } );
+    bool result =
+        std::any_of( validPerimeterNames.begin(), validPerimeterNames.end(), [line]( const QString& str ) { return line.contains( str ); } );
 
     return result;
 }
@@ -248,15 +245,12 @@ std::pair<QString, QString> RifThermalFractureReader::parseNameAndUnit( const QS
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RiaDefines::EclipseUnitSystem
-    RifThermalFractureReader::detectUnitSystem( std::shared_ptr<const RigThermalFractureDefinition> definition )
+RiaDefines::EclipseUnitSystem RifThermalFractureReader::detectUnitSystem( std::shared_ptr<const RigThermalFractureDefinition> definition )
 {
     // Use XCoord property to determine expected unit for entire file
     QString targetName    = "XCoord";
     auto    namesAndUnits = definition->getPropertyNamesUnits();
-    auto    res           = std::find_if( namesAndUnits.begin(), namesAndUnits.end(), [&]( const auto& val ) {
-        return val.first == targetName;
-    } );
+    auto    res = std::find_if( namesAndUnits.begin(), namesAndUnits.end(), [&]( const auto& val ) { return val.first == targetName; } );
 
     if ( res != namesAndUnits.end() )
     {

ApplicationLibCode/FileInterface/RifThermalFractureReader.h

@@ -46,8 +46,7 @@ private:
     static std::pair<QString, QString> parseNameAndUnit( const QString& value );
 
     static RiaDefines::EclipseUnitSystem detectUnitSystem( std::shared_ptr<const RigThermalFractureDefinition> definition );
-    static bool                          checkUnits( std::shared_ptr<const RigThermalFractureDefinition> definition,
-                                                     RiaDefines::EclipseUnitSystem                       unitSystem );
+    static bool checkUnits( std::shared_ptr<const RigThermalFractureDefinition> definition, RiaDefines::EclipseUnitSystem unitSystem );
 
     static QString getExpectedUnit( const QString& name, RiaDefines::EclipseUnitSystem unitSystem );
 };

ApplicationLibCode/FileInterface/RifThermalFractureTemplateSurfaceExporter.h

@@ -29,7 +29,5 @@ class QString;
 class RifThermalFractureTemplateSurfaceExporter
 {
 public:
-    static bool writeToFile( gsl::not_null<RimThermalFractureTemplate*> thermalFractureTemplate,
-                             int                                        timeStep,
-                             const QString&                             filePath );
+    static bool writeToFile( gsl::not_null<RimThermalFractureTemplate*> thermalFractureTemplate, int timeStep, const QString& filePath );
 };