clang-format : Set AllowAllParametersOfDeclarationOnNextLine to false

ApplicationCode/.clang-format

@@ -8,7 +8,7 @@ AlignConsecutiveDeclarations: true
 AlignEscapedNewlinesLeft: true
 AlignOperands:   true
 AlignTrailingComments: false
-AllowAllParametersOfDeclarationOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: false
 AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: false
 AllowShortIfStatementsOnASingleLine: true

ApplicationCode/Application/Tools/RiaProjectFileVersionTools.cpp

@@ -61,8 +61,11 @@ bool RiaProjectFileVersionTools::isCandidateVersionNewerThanOther( const QString
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RiaProjectFileVersionTools::decodeVersionString(
+void RiaProjectFileVersionTools::decodeVersionString( const QString& projectFileVersion,
-    const QString& projectFileVersion, int* majorVersion, int* minorVersion, int* patch, int* developmentId )
+                                                      int*           majorVersion,
+                                                      int*           minorVersion,
+                                                      int*           patch,
+                                                      int*           developmentId )
 {
     if ( projectFileVersion.isEmpty() ) return;
 

ApplicationCode/Application/Tools/RiaProjectFileVersionTools.h

@@ -30,8 +30,11 @@ public:
                                                   const QString& otherProjectFileVersion );
 
     // Public to be able to unit test function, not intended to be used
-    static void decodeVersionString(
+    static void decodeVersionString( const QString& projectFileVersion,
-        const QString& projectFileVersion, int* majorVersion, int* minorVersion, int* patch, int* developmentId );
+                                     int*           majorVersion,
+                                     int*           minorVersion,
+                                     int*           patch,
+                                     int*           developmentId );
 
 private:
     static bool isCandidateNewerThanOther( int candidateMajorVersion,

ApplicationCode/Application/Tools/WellPathTools/RiaSCurveCalculator.cpp

@@ -28,8 +28,14 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RiaSCurveCalculator::RiaSCurveCalculator(
+RiaSCurveCalculator::RiaSCurveCalculator( cvf::Vec3d p1,
-    cvf::Vec3d p1, double azi1, double inc1, double rad1, cvf::Vec3d p2, double azi2, double inc2, double rad2 )
+                                          double     azi1,
+                                          double     inc1,
+                                          double     rad1,
+                                          cvf::Vec3d p2,
+                                          double     azi2,
+                                          double     inc2,
+                                          double     rad2 )
     : m_isCalculationOK( false )
     , m_p1( p1 )
     , m_p2( p2 )
@@ -145,8 +151,14 @@ RiaSCurveCalculator::RiaSCurveCalculator( cvf::Vec3d p1, cvf::Vec3d q1, cvf::Vec
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RiaSCurveCalculator RiaSCurveCalculator::fromTangentsAndLength(
+RiaSCurveCalculator RiaSCurveCalculator::fromTangentsAndLength( cvf::Vec3d p1,
-    cvf::Vec3d p1, double azi1, double inc1, double lengthToQ1, cvf::Vec3d p2, double azi2, double inc2, double lengthToQ2 )
+                                                                double     azi1,
+                                                                double     inc1,
+                                                                double     lengthToQ1,
+                                                                cvf::Vec3d p2,
+                                                                double     azi2,
+                                                                double     inc2,
+                                                                double     lengthToQ2 )
 {
     cvf::Vec3d t1( RiaOffshoreSphericalCoords::unitVectorFromAziInc( azi1, inc1 ) );
     cvf::Vec3d t2( RiaOffshoreSphericalCoords::unitVectorFromAziInc( azi2, inc2 ) );
@@ -209,8 +221,14 @@ bool isZeroCrossing( double newError, double oldError, double maxError )
 /// R1(q1, q2), R2(q1, q2)
 ///
 //--------------------------------------------------------------------------------------------------
-void RiaSCurveCalculator::initializeByFinding_q1q2(
+void RiaSCurveCalculator::initializeByFinding_q1q2( cvf::Vec3d p1,
-    cvf::Vec3d p1, double azi1, double inc1, double r1, cvf::Vec3d p2, double azi2, double inc2, double r2 )
+                                                    double     azi1,
+                                                    double     inc1,
+                                                    double     r1,
+                                                    cvf::Vec3d p2,
+                                                    double     azi2,
+                                                    double     inc2,
+                                                    double     r2 )
 {
     // Algorithm options
 

ApplicationCode/Application/Tools/WellPathTools/RiaSCurveCalculator.h

@@ -23,8 +23,7 @@
 class RiaSCurveCalculator
 {
 public:
-    RiaSCurveCalculator(
+    RiaSCurveCalculator( cvf::Vec3d p1, double azi1, double inc1, double r1, cvf::Vec3d p2, double azi2, double inc2, double r2 );
-        cvf::Vec3d p1, double azi1, double inc1, double r1, cvf::Vec3d p2, double azi2, double inc2, double r2 );
 
     RiaSCurveCalculator( cvf::Vec3d p1, cvf::Vec3d q1, cvf::Vec3d p2, cvf::Vec3d q2 );
 
@@ -105,8 +104,14 @@ public:
                                                       double     lengthToQ2 );
 
 private:
-    void initializeByFinding_q1q2(
+    void initializeByFinding_q1q2( cvf::Vec3d p1,
-        cvf::Vec3d p1, double azi1, double inc1, double r1, cvf::Vec3d p2, double azi2, double inc2, double r2 );
+                                   double     azi1,
+                                   double     inc1,
+                                   double     r1,
+                                   cvf::Vec3d p2,
+                                   double     azi2,
+                                   double     inc2,
+                                   double     r2 );
 
     bool m_isCalculationOK;
 

ApplicationCode/Commands/CompletionExportCommands/RicExportFractureCompletionsImpl.cpp

@@ -531,7 +531,9 @@ bool RicExportFractureCompletionsImpl::checkForStimPlanConductivity( const RimFr
 ///
 //--------------------------------------------------------------------------------------------------
 void RicExportFractureCompletionsImpl::calculateInternalFractureTransmissibilities(
-    const RigFractureGrid* fractureGrid, double cDarcyInCorrectUnit, RigTransmissibilityCondenser& transCondenser )
+    const RigFractureGrid*        fractureGrid,
+    double                        cDarcyInCorrectUnit,
+    RigTransmissibilityCondenser& transCondenser )
 {
     for ( size_t i = 0; i < fractureGrid->iCellCount(); i++ )
     {
@@ -732,7 +734,8 @@ std::vector<RigCompletionData> RicExportFractureCompletionsImpl::generateCompdat
 ///
 //--------------------------------------------------------------------------------------------------
 void RicExportFractureCompletionsImpl::computeNonDarcyFlowParameters(
-    const RimFracture* fracture, std::vector<RigCompletionData>& allCompletionsForOneFracture )
+    const RimFracture*              fracture,
+    std::vector<RigCompletionData>& allCompletionsForOneFracture )
 {
     double dFactorForFracture = fracture->nonDarcyProperties().dFactor;
     double khForFracture      = fracture->nonDarcyProperties().conductivity;

ApplicationCode/Commands/CompletionExportCommands/RicFishbonesTransmissibilityCalculationFeatureImp.cpp

@@ -46,8 +46,11 @@
 //==================================================================================================
 struct WellBorePartForTransCalc
 {
-    WellBorePartForTransCalc(
+    WellBorePartForTransCalc( cvf::Vec3d     lengthsInCell,
-        cvf::Vec3d lengthsInCell, double wellRadius, double skinFactor, bool isMainBore, const QString& metaData )
+                              double         wellRadius,
+                              double         skinFactor,
+                              bool           isMainBore,
+                              const QString& metaData )
         : lengthsInCell( lengthsInCell )
         , wellRadius( wellRadius )
         , skinFactor( skinFactor )
@@ -79,7 +82,8 @@ struct WellBorePartForTransCalc
 //--------------------------------------------------------------------------------------------------
 std::vector<RigCompletionData>
     RicFishbonesTransmissibilityCalculationFeatureImp::generateFishboneCompdatValuesUsingAdjustedCellVolume(
-        const RimWellPath* wellPath, const RicExportCompletionDataSettingsUi& settings )
+        const RimWellPath*                       wellPath,
+        const RicExportCompletionDataSettingsUi& settings )
 {
     std::vector<RigCompletionData> completionData;
 

ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeature.cpp

@@ -50,7 +50,9 @@ CAF_CMD_SOURCE_INIT( RicWellPathExportCompletionDataFeature, "RicWellPathExportC
 ///
 //--------------------------------------------------------------------------------------------------
 void RicWellPathExportCompletionDataFeature::prepareExportSettingsAndExportCompletions(
-    const QString& dialogTitle, const std::vector<RimWellPath*>& wellPaths, const std::vector<RimSimWellInView*>& simWells )
+    const QString&                        dialogTitle,
+    const std::vector<RimWellPath*>&      wellPaths,
+    const std::vector<RimSimWellInView*>& simWells )
 {
     RiaApplication* app        = RiaApplication::instance();
     RimProject*     project    = app->project();

ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeatureImpl.cpp

@@ -460,8 +460,10 @@ std::vector<RigCompletionData>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RigCompletionData> RicWellPathExportCompletionDataFeatureImpl::computeDynamicCompletionsForWellPath(
+std::vector<RigCompletionData>
-    RimWellPath* wellPath, RimEclipseCase* eclipseCase, size_t timeStepIndex )
+    RicWellPathExportCompletionDataFeatureImpl::computeDynamicCompletionsForWellPath( RimWellPath*    wellPath,
+                                                                                      RimEclipseCase* eclipseCase,
+                                                                                      size_t          timeStepIndex )
 {
     std::vector<RigCompletionData> completionsPerEclipseCell;
 
@@ -487,7 +489,8 @@ std::vector<RigCompletionData> RicWellPathExportCompletionDataFeatureImpl::compu
 ///
 //==================================================================================================
 RigCompletionData RicWellPathExportCompletionDataFeatureImpl::combineEclipseCellCompletions(
-    const std::vector<RigCompletionData>& completions, const RicExportCompletionDataSettingsUi& settings )
+    const std::vector<RigCompletionData>&    completions,
+    const RicExportCompletionDataSettingsUi& settings )
 {
     CVF_ASSERT( !completions.empty() );
 
@@ -780,7 +783,9 @@ void RicWellPathExportCompletionDataFeatureImpl::exportWelspecsToFile( RimEclips
 ///
 //--------------------------------------------------------------------------------------------------
 void RicWellPathExportCompletionDataFeatureImpl::exportWelspeclToFile(
-    RimEclipseCase* gridCase, QFilePtr exportFile, const std::map<QString, std::vector<RigCompletionData>>& completions )
+    RimEclipseCase*                                          gridCase,
+    QFilePtr                                                 exportFile,
+    const std::map<QString, std::vector<RigCompletionData>>& completions )
 {
     QTextStream stream( exportFile.get() );
 
@@ -958,7 +963,9 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompdatAndWpimultTables(
 ///
 //--------------------------------------------------------------------------------------------------
 void RicWellPathExportCompletionDataFeatureImpl::exportCompdatTableUsingFormatter(
-    RifTextDataTableFormatter& formatter, const QString& gridName, const std::vector<RigCompletionData>& completionData )
+    RifTextDataTableFormatter&            formatter,
+    const QString&                        gridName,
+    const std::vector<RigCompletionData>& completionData )
 {
     std::vector<RifTextDataTableColumn> header;
 
@@ -1094,7 +1101,9 @@ void RicWellPathExportCompletionDataFeatureImpl::exportCompdatTableUsingFormatte
 ///
 //--------------------------------------------------------------------------------------------------
 void RicWellPathExportCompletionDataFeatureImpl::exportWpimultTableUsingFormatter(
-    RifTextDataTableFormatter& formatter, const QString& gridName, const std::vector<RigCompletionData>& completionData )
+    RifTextDataTableFormatter&            formatter,
+    const QString&                        gridName,
+    const std::vector<RigCompletionData>& completionData )
 {
     std::vector<RifTextDataTableColumn> header;
 
@@ -1531,8 +1540,11 @@ double RicWellPathExportCompletionDataFeatureImpl::calculateDFactor( RimEclipseC
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RicWellPathExportCompletionDataFeatureImpl::calculateTransmissibilityAsEclipseDoes(
+double RicWellPathExportCompletionDataFeatureImpl::calculateTransmissibilityAsEclipseDoes( RimEclipseCase* eclipseCase,
-    RimEclipseCase* eclipseCase, double skinFactor, double wellRadius, size_t globalCellIndex, CellDirection direction )
+                                                                                           double          skinFactor,
+                                                                                           double          wellRadius,
+                                                                                           size_t globalCellIndex,
+                                                                                           CellDirection direction )
 {
     RigEclipseCaseData* eclipseCaseData = eclipseCase->eclipseCaseData();
 
@@ -1651,8 +1663,10 @@ double RicWellPathExportCompletionDataFeatureImpl::calculateTransmissibilityAsEc
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::pair<double, cvf::Vec2i> RicWellPathExportCompletionDataFeatureImpl::wellPathUpperGridIntersectionIJ(
+std::pair<double, cvf::Vec2i>
-    const RimEclipseCase* gridCase, const RimWellPath* wellPath, const QString& gridName )
+    RicWellPathExportCompletionDataFeatureImpl::wellPathUpperGridIntersectionIJ( const RimEclipseCase* gridCase,
+                                                                                 const RimWellPath*    wellPath,
+                                                                                 const QString&        gridName )
 {
     const RigEclipseCaseData*      caseData         = gridCase->eclipseCaseData();
     const RigMainGrid*             mainGrid         = caseData->mainGrid();

ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportMswCompletionsImpl.cpp

@@ -59,8 +59,12 @@
 class SubSegmentIntersectionInfo
 {
 public:
-    SubSegmentIntersectionInfo(
+    SubSegmentIntersectionInfo( size_t     globCellIndex,
-        size_t globCellIndex, double startTVD, double endTVD, double startMD, double endMD, cvf::Vec3d lengthsInCell );
+                                double     startTVD,
+                                double     endTVD,
+                                double     startMD,
+                                double     endMD,
+                                cvf::Vec3d lengthsInCell );
     static std::vector<SubSegmentIntersectionInfo>
                spiltIntersectionSegmentsToMaxLength( const RigWellPath*                               pathGeometry,
                                                      const std::vector<WellPathCellIntersectionInfo>& intersections,
@@ -79,7 +83,8 @@ public:
 ///
 //--------------------------------------------------------------------------------------------------
 void RicWellPathExportMswCompletionsImpl::exportWellSegmentsForAllCompletions(
-    const RicExportCompletionDataSettingsUi& exportSettings, const std::vector<RimWellPath*>& wellPaths )
+    const RicExportCompletionDataSettingsUi& exportSettings,
+    const std::vector<RimWellPath*>&         wellPaths )
 {
     std::shared_ptr<QFile> unifiedExportFile;
     if ( exportSettings.fileSplit() == RicExportCompletionDataSettingsUi::UNIFIED_FILE )
@@ -436,7 +441,8 @@ void RicWellPathExportMswCompletionsImpl::generateWelsegsSegments(
 ///
 //--------------------------------------------------------------------------------------------------
 void RicWellPathExportMswCompletionsImpl::generateWelsegsCompletionCommentHeader(
-    RifTextDataTableFormatter& formatter, RigCompletionData::CompletionType completionType )
+    RifTextDataTableFormatter&        formatter,
+    RigCompletionData::CompletionType completionType )
 {
     if ( completionType == RigCompletionData::CT_UNDEFINED )
     {
@@ -921,7 +927,9 @@ RicMswExportInfo RicWellPathExportMswCompletionsImpl::generateFracturesMswExport
 ///
 //--------------------------------------------------------------------------------------------------
 RicMswExportInfo RicWellPathExportMswCompletionsImpl::generateFracturesMswExportInfo(
-    RimEclipseCase* caseToApply, const RimWellPath* wellPath, const std::vector<RimWellPathFracture*>& fractures )
+    RimEclipseCase*                          caseToApply,
+    const RimWellPath*                       wellPath,
+    const std::vector<RimWellPathFracture*>& fractures )
 {
     const RigMainGrid*       grid           = caseToApply->eclipseCaseData()->mainGrid();
     const RigActiveCellInfo* activeCellInfo = caseToApply->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL );
@@ -1611,7 +1619,10 @@ void RicWellPathExportMswCompletionsImpl::assignFractureIntersections( const Rim
 ///
 //--------------------------------------------------------------------------------------------------
 std::vector<RigCompletionData> RicWellPathExportMswCompletionsImpl::generatePerforationIntersections(
-    const RimWellPath* wellPath, const RimPerforationInterval* perforationInterval, int timeStep, RimEclipseCase* eclipseCase )
+    const RimWellPath*            wellPath,
+    const RimPerforationInterval* perforationInterval,
+    int                           timeStep,
+    RimEclipseCase*               eclipseCase )
 {
     std::vector<RigCompletionData> completionData;
     const RigActiveCellInfo* activeCellInfo = eclipseCase->eclipseCaseData()->activeCellInfo( RiaDefines::MATRIX_MODEL );
@@ -1757,8 +1768,12 @@ void RicWellPathExportMswCompletionsImpl::assignBranchAndSegmentNumbers( const R
     }
 }
 
-SubSegmentIntersectionInfo::SubSegmentIntersectionInfo(
+SubSegmentIntersectionInfo::SubSegmentIntersectionInfo( size_t     globCellIndex,
-    size_t globCellIndex, double startTVD, double endTVD, double startMD, double endMD, cvf::Vec3d lengthsInCell )
+                                                        double     startTVD,
+                                                        double     endTVD,
+                                                        double     startMD,
+                                                        double     endMD,
+                                                        cvf::Vec3d lengthsInCell )
     : globCellIndex( globCellIndex )
     , startTVD( startTVD )
     , endTVD( endTVD )

ApplicationCode/Commands/CrossSectionCommands/RicCopyIntersectionsToAllViewsInCaseFeature.cpp

@@ -109,8 +109,8 @@ void RicCopyIntersectionsToAllViewsInCaseFeature::setupActionLook( QAction* acti
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RicCopyIntersectionsToAllViewsInCaseFeature::copyIntersectionsToOtherViews(
+void RicCopyIntersectionsToAllViewsInCaseFeature::copyIntersectionsToOtherViews( RimCase&                      gridCase,
-    RimCase& gridCase, std::vector<RimIntersection*> intersections )
+                                                                                 std::vector<RimIntersection*> intersections )
 {
     for ( RimIntersection* intersection : intersections )
     {
@@ -142,7 +142,8 @@ void RicCopyIntersectionsToAllViewsInCaseFeature::copyIntersectionsToOtherViews(
 ///
 //--------------------------------------------------------------------------------------------------
 void RicCopyIntersectionsToAllViewsInCaseFeature::copyIntersectionBoxesToOtherViews(
-    RimCase& gridCase, std::vector<RimIntersectionBox*> intersectionBoxes )
+    RimCase&                         gridCase,
+    std::vector<RimIntersectionBox*> intersectionBoxes )
 {
     for ( RimIntersectionBox* intersectionBox : intersectionBoxes )
     {

ApplicationCode/Commands/CrossSectionCommands/RicNewWellPathIntersectionFeature.cpp

@@ -79,8 +79,8 @@ void RicNewWellPathIntersectionFeature::setupActionLook( QAction* actionToSetup
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RicNewWellPathIntersectionFeatureCmd::RicNewWellPathIntersectionFeatureCmd(
+RicNewWellPathIntersectionFeatureCmd::RicNewWellPathIntersectionFeatureCmd( RimIntersectionCollection* intersectionCollection,
-    RimIntersectionCollection* intersectionCollection, RimWellPath* wellPath )
+                                                                            RimWellPath*               wellPath )
     : CmdExecuteCommand( nullptr )
     , m_intersectionCollection( intersectionCollection )
     , m_wellPath( wellPath )

ApplicationCode/Commands/FlowCommands/RicShowContributingWellsFeatureImpl.cpp

@@ -178,8 +178,10 @@ void RicShowContributingWellsFeatureImpl::modifyViewToShowContributingWells( Rim
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<QString> RicShowContributingWellsFeatureImpl::findContributingTracerNames(
+std::vector<QString>
-    const RimFlowDiagSolution* flowDiagSolution, const RigSimWellData* simWellData, int timeStep )
+    RicShowContributingWellsFeatureImpl::findContributingTracerNames( const RimFlowDiagSolution* flowDiagSolution,
+                                                                      const RigSimWellData*      simWellData,
+                                                                      int                        timeStep )
 {
     std::vector<QString> tracerCellFractionValues;
 

ApplicationCode/Commands/HoloLensCommands/VdeCachingHashedIdFactory.cpp

@@ -120,8 +120,11 @@ int VdeCachingHashedIdFactory::lastAssignedId() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-int VdeCachingHashedIdFactory::getOrCreateIdForArrOfType(
+int VdeCachingHashedIdFactory::getOrCreateIdForArrOfType( ArrayRole   arrayRole,
-    ArrayRole arrayRole, ElementType elementType, size_t elementSizeInBytes, const void* data, size_t elementCount )
+                                                          ElementType elementType,
+                                                          size_t      elementSizeInBytes,
+                                                          const void* data,
+                                                          size_t      elementCount )
 {
     Key key;
     key.elementType  = elementType;

ApplicationCode/Commands/HoloLensCommands/VdeCachingHashedIdFactory.h

@@ -64,8 +64,11 @@ private:
     };
 
 private:
-    int getOrCreateIdForArrOfType(
+    int getOrCreateIdForArrOfType( ArrayRole   arrayRole,
-        ArrayRole arrayRole, ElementType elementType, size_t elementSizeInBytes, const void* data, size_t elementCount );
+                                   ElementType elementType,
+                                   size_t      elementSizeInBytes,
+                                   const void* data,
+                                   size_t      elementCount );
 
 private:
     std::map<Key, int> m_keyToIdMap;

ApplicationCode/Commands/RicNewContourMapViewFeature.cpp

@@ -166,7 +166,8 @@ void RicNewContourMapViewFeature::setupActionLook( QAction* actionToSetup )
 ///
 //--------------------------------------------------------------------------------------------------
 RimEclipseContourMapView* RicNewContourMapViewFeature::createEclipseContourMapFromExistingContourMap(
-    RimEclipseCase* eclipseCase, RimEclipseContourMapView* existingContourMap )
+    RimEclipseCase*           eclipseCase,
+    RimEclipseContourMapView* existingContourMap )
 {
     RimEclipseContourMapView* contourMap = dynamic_cast<RimEclipseContourMapView*>(
         existingContourMap->xmlCapability()->copyByXmlSerialization( caf::PdmDefaultObjectFactory::instance() ) );
@@ -260,7 +261,8 @@ RimEclipseContourMapView* RicNewContourMapViewFeature::createEclipseContourMap(
 ///
 //--------------------------------------------------------------------------------------------------
 RimGeoMechContourMapView* RicNewContourMapViewFeature::createGeoMechContourMapFromExistingContourMap(
-    RimGeoMechCase* geoMechCase, RimGeoMechContourMapView* existingContourMap )
+    RimGeoMechCase*           geoMechCase,
+    RimGeoMechContourMapView* existingContourMap )
 {
     RimGeoMechContourMapView* contourMap = dynamic_cast<RimGeoMechContourMapView*>(
         existingContourMap->xmlCapability()->copyByXmlSerialization( caf::PdmDefaultObjectFactory::instance() ) );

ApplicationCode/Commands/SummaryPlotCommands/RicSummaryCurveCalculatorEditor.cpp

@@ -62,7 +62,8 @@ RicSummaryCurveCalculatorEditor::~RicSummaryCurveCalculatorEditor()
 ///
 //--------------------------------------------------------------------------------------------------
 void RicSummaryCurveCalculatorEditor::recursivelyConfigureAndUpdateTopLevelUiOrdering(
-    const caf::PdmUiOrdering& topLevelUiOrdering, const QString& uiConfigName )
+    const caf::PdmUiOrdering& topLevelUiOrdering,
+    const QString&            uiConfigName )
 {
     if ( !m_firstRowLeftLayout || !m_firstRowRightLayout ) return;
 

ApplicationCode/Commands/SummaryPlotCommands/RicSummaryCurveCreatorSplitterUi.cpp

@@ -76,7 +76,8 @@ void RicSummaryCurveCreatorSplitterUi::updateFromDefaultSources( const std::vect
 ///
 //--------------------------------------------------------------------------------------------------
 void RicSummaryCurveCreatorSplitterUi::recursivelyConfigureAndUpdateTopLevelUiOrdering(
-    const caf::PdmUiOrdering& topLevelUiOrdering, const QString& uiConfigName )
+    const caf::PdmUiOrdering& topLevelUiOrdering,
+    const QString&            uiConfigName )
 {
     const std::vector<caf::PdmUiItem*>& topLevelUiItems = topLevelUiOrdering.uiItems();
     if ( m_summaryCurveCreator->isCloseButtonPressed() )

ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.cpp

@@ -755,8 +755,10 @@ std::set<RifEclipseSummaryAddress>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RimSummaryCurve*> RicSummaryPlotFeatureImpl::addCurvesFromAddressFiltersToPlot(
+std::vector<RimSummaryCurve*> RicSummaryPlotFeatureImpl::addCurvesFromAddressFiltersToPlot( const QStringList& curveFilters,
-    const QStringList& curveFilters, RimSummaryPlot* plot, RimSummaryCase* summaryCase, bool addHistoryCurves )
+                                                                                            RimSummaryPlot* plot,
+                                                                                            RimSummaryCase* summaryCase,
+                                                                                            bool addHistoryCurves )
 {
     std::vector<RimSummaryCurve*> createdCurves;
 

ApplicationCode/Commands/SummaryPlotCommands/RicSummaryPlotFeatureImpl.h

@@ -83,8 +83,11 @@ public:
     {
     }
 
-    RigGridCellResultAddress(
+    RigGridCellResultAddress( size_t                         gridIndex,
-        size_t gridIndex, size_t i, size_t j, size_t k, const RigEclipseResultAddress& eclipseResultAddress )
+                              size_t                         i,
+                              size_t                         j,
+                              size_t                         k,
+                              const RigEclipseResultAddress& eclipseResultAddress )
         : gridIndex( gridIndex )
         , i( i )
         , j( j )

ApplicationCode/FileInterface/RifEclipseSummaryAddress.cpp

@@ -400,8 +400,11 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellAddress( const std::strin
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionAddress(
+RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionAddress( const std::string& quantityName,
-    const std::string& quantityName, const std::string& wellName, int i, int j, int k )
+                                                                          const std::string& wellName,
+                                                                          int                i,
+                                                                          int                j,
+                                                                          int                k )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_WELL_COMPLETION;
@@ -431,8 +434,12 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::wellLgrAddress( const std::st
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionLgrAddress(
+RifEclipseSummaryAddress RifEclipseSummaryAddress::wellCompletionLgrAddress( const std::string& quantityName,
-    const std::string& quantityName, const std::string& lgrName, const std::string& wellName, int i, int j, int k )
+                                                                             const std::string& lgrName,
+                                                                             const std::string& wellName,
+                                                                             int                i,
+                                                                             int                j,
+                                                                             int                k )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_WELL_COMPLETION_LGR;
@@ -477,8 +484,11 @@ RifEclipseSummaryAddress RifEclipseSummaryAddress::blockAddress( const std::stri
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RifEclipseSummaryAddress RifEclipseSummaryAddress::blockLgrAddress(
+RifEclipseSummaryAddress RifEclipseSummaryAddress::blockLgrAddress( const std::string& quantityName,
-    const std::string& quantityName, const std::string& lgrName, int i, int j, int k )
+                                                                    const std::string& lgrName,
+                                                                    int                i,
+                                                                    int                j,
+                                                                    int                k )
 {
     RifEclipseSummaryAddress addr;
     addr.m_variableCategory = SUMMARY_BLOCK_LGR;

ApplicationCode/FileInterface/RifEclipseSummaryAddress.h

@@ -136,8 +136,12 @@ public:
         wellCompletionAddress( const std::string& quantityName, const std::string& wellName, int i, int j, int k );
     static RifEclipseSummaryAddress
                                     wellLgrAddress( const std::string& quantityName, const std::string& lgrName, const std::string& wellName );
-    static RifEclipseSummaryAddress wellCompletionLgrAddress(
+    static RifEclipseSummaryAddress wellCompletionLgrAddress( const std::string& quantityName,
-        const std::string& quantityName, const std::string& lgrName, const std::string& wellName, int i, int j, int k );
+                                                              const std::string& lgrName,
+                                                              const std::string& wellName,
+                                                              int                i,
+                                                              int                j,
+                                                              int                k );
     static RifEclipseSummaryAddress
                                     wellSegmentAddress( const std::string& quantityName, const std::string& wellName, int segmentNumber );
     static RifEclipseSummaryAddress blockAddress( const std::string& quantityName, int i, int j, int k );

ApplicationCode/FileInterface/RifEclipseSummaryTools.cpp

@@ -159,8 +159,11 @@ void RifEclipseSummaryTools::dumpMetaData( RifSummaryReaderInterface* readerEcli
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RifEclipseSummaryTools::findSummaryHeaderFileInfo(
+void RifEclipseSummaryTools::findSummaryHeaderFileInfo( const QString& inputFile,
-    const QString& inputFile, QString* headerFile, QString* path, QString* base, bool* isFormatted )
+                                                        QString*       headerFile,
+                                                        QString*       path,
+                                                        QString*       base,
+                                                        bool*          isFormatted )
 {
     char* myPath        = nullptr;
     char* myBase        = nullptr;

ApplicationCode/FileInterface/RifEclipseSummaryTools.h

@@ -42,6 +42,9 @@ public:
     static void dumpMetaData( RifSummaryReaderInterface* readerEclipseSummary );
 
 private:
-    static void findSummaryHeaderFileInfo(
+    static void findSummaryHeaderFileInfo( const QString& inputFile,
-        const QString& inputFile, QString* headerFile, QString* path, QString* base, bool* isFormatted );
+                                           QString*       headerFile,
+                                           QString*       path,
+                                           QString*       base,
+                                           bool*          isFormatted );
 };

ApplicationCode/FileInterface/RifReaderEclipseRft.cpp

@@ -285,8 +285,9 @@ std::set<QDateTime>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::set<QDateTime> RifReaderEclipseRft::availableTimeSteps(
+std::set<QDateTime>
-    const QString& wellName, const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
+    RifReaderEclipseRft::availableTimeSteps( const QString&                                               wellName,
+                                             const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
 {
     if ( !m_ecl_rft_file )
     {

ApplicationCode/FileInterface/RifReaderEnsembleStatisticsRft.cpp

@@ -114,7 +114,8 @@ std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps( const QS
 ///
 //--------------------------------------------------------------------------------------------------
 std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps(
-    const QString& wellName, const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
+    const QString&                                     wellName,
+    const RifEclipseRftAddress::RftWellLogChannelType& wellLogChannelName )
 {
     std::set<QDateTime> allTimeSteps;
     for ( auto summaryCase : m_summaryCaseCollection->allSummaryCases() )
@@ -132,7 +133,8 @@ std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps(
 ///
 //--------------------------------------------------------------------------------------------------
 std::set<QDateTime> RifReaderEnsembleStatisticsRft::availableTimeSteps(
-    const QString& wellName, const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
+    const QString&                                               wellName,
+    const std::set<RifEclipseRftAddress::RftWellLogChannelType>& relevantChannels )
 {
     std::set<QDateTime> allTimeSteps;
     for ( auto summaryCase : m_summaryCaseCollection->allSummaryCases() )

ApplicationCode/FileInterface/RifSummaryCaseRestartSelector.cpp

@@ -162,7 +162,8 @@ void RifSummaryCaseRestartSelector::determineFilesToImport( const std::vector<Ri
 ///
 //--------------------------------------------------------------------------------------------------
 void RifSummaryCaseRestartSelector::determineFilesToImportByAskingUser(
-    const std::vector<RifSummaryCaseFileImportInfo>& initialFiles, bool enableApplyToAllField )
+    const std::vector<RifSummaryCaseFileImportInfo>& initialFiles,
+    bool                                             enableApplyToAllField )
 {
     RicSummaryCaseRestartDialogResult lastResult;
 

ApplicationCode/GeoMech/GeoMechDataModel/RigFemPartResultsCollection.cpp

@@ -519,8 +519,10 @@ std::map<std::string, std::vector<std::string>>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RigFemScalarResultFrames* RigFemPartResultsCollection::calculateBarConvertedResult(
+RigFemScalarResultFrames*
-    int partIndex, const RigFemResultAddress& convertedResultAddr, const std::string& fieldNameToConvert )
+    RigFemPartResultsCollection::calculateBarConvertedResult( int                        partIndex,
+                                                              const RigFemResultAddress& convertedResultAddr,
+                                                              const std::string&         fieldNameToConvert )
 {
     caf::ProgressInfo frameCountProgress( this->frameCount() * 2, "" );
     frameCountProgress.setProgressDescription(

ApplicationCode/ModelVisualization/Riv3dWellLogCurveGeometryGenerator.cpp

@@ -382,8 +382,9 @@ void Riv3dWellLogCurveGeometryGenerator::createNewVerticesAlongSegment( const cv
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<cvf::Vec3d> Riv3dWellLogCurveGeometryGenerator::projectVerticesOntoTriangles(
+std::vector<cvf::Vec3d>
-    const std::vector<cvf::Vec3d>& originalVertices, const std::vector<cvf::Vec3d>& drawSurfaceVertices )
+    Riv3dWellLogCurveGeometryGenerator::projectVerticesOntoTriangles( const std::vector<cvf::Vec3d>& originalVertices,
+                                                                      const std::vector<cvf::Vec3d>& drawSurfaceVertices )
 {
     std::vector<cvf::Vec3d> projectedVertices;
     projectedVertices.reserve( originalVertices.size() );

ApplicationCode/ModelVisualization/RivCellEdgeGeometryUtils.cpp

@@ -371,8 +371,10 @@ cvf::ref<RigResultAccessor>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellCenterResultAccessor(
+cvf::ref<RigResultAccessor> RivCellEdgeGeometryUtils::createCellCenterResultAccessor( RimEclipseCellColors* cellResultColors,
-    RimEclipseCellColors* cellResultColors, size_t timeStepIndex, RigEclipseCaseData* eclipseCase, const RigGridBase* grid )
+                                                                                      size_t              timeStepIndex,
+                                                                                      RigEclipseCaseData* eclipseCase,
+                                                                                      const RigGridBase*  grid )
 {
     cvf::ref<RigResultAccessor> resultAccessor = nullptr;
 

ApplicationCode/ModelVisualization/RivContourMapProjectionPartMgr.cpp

@@ -543,7 +543,8 @@ cvf::ref<cvf::DrawableGeo> RivContourMapProjectionPartMgr::createPickPointVisDra
 ///
 //--------------------------------------------------------------------------------------------------
 bool RivContourMapProjectionPartMgr::lineOverlapsWithPreviousContourLevel(
-    const cvf::Vec3d& lineCenter, const RimContourMapProjection::ContourPolygons* previousLevel ) const
+    const cvf::Vec3d&                               lineCenter,
+    const RimContourMapProjection::ContourPolygons* previousLevel ) const
 {
     const int64_t jump = 50;
     CVF_ASSERT( previousLevel );

ApplicationCode/ModelVisualization/RivPipeGeometryGenerator.cpp

@@ -242,8 +242,9 @@ cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateLine( const cvf::Ve
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateExtrudedCylinder(
+cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateExtrudedCylinder( double radius,
-    double radius, size_t crossSectionNodeCount, const cvf::Vec3dArray* cylinderCenterCoords )
+                                                                               size_t crossSectionNodeCount,
+                                                                               const cvf::Vec3dArray* cylinderCenterCoords )
 {
     CVF_ASSERT( cylinderCenterCoords != nullptr );
 
@@ -396,8 +397,9 @@ cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateExtrudedCylinder(
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateVariableRadiusTube(
+cvf::ref<cvf::DrawableGeo> RivPipeGeometryGenerator::generateVariableRadiusTube( size_t crossSectionNodeCount,
-    size_t crossSectionNodeCount, const cvf::Vec3dArray* cylinderCenterCoords, const std::vector<double>& radii )
+                                                                                 const cvf::Vec3dArray* cylinderCenterCoords,
+                                                                                 const std::vector<double>& radii )
 {
     CVF_ASSERT( cylinderCenterCoords != nullptr );
 

ApplicationCode/ModelVisualization/RivPolylineAnnotationPartMgr.cpp

@@ -202,8 +202,9 @@ std::vector<std::vector<RivPolylineAnnotationPartMgr::Vec3d>>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<std::vector<cvf::Vec3d>> RivPolylineAnnotationPartMgr::transformPolylinesPointsToDisplay(
+std::vector<std::vector<cvf::Vec3d>>
-    const std::vector<std::vector<Vec3d>>& pointsInDomain, const caf::DisplayCoordTransform* displayXf )
+    RivPolylineAnnotationPartMgr::transformPolylinesPointsToDisplay( const std::vector<std::vector<Vec3d>>& pointsInDomain,
+                                                                     const caf::DisplayCoordTransform*      displayXf )
 {
     std::vector<std::vector<Vec3d>> pointsInDisplay;
     for ( const auto& pts : pointsInDomain )

ApplicationCode/ModelVisualization/RivTernarySaturationOverlayItem.cpp

@@ -176,8 +176,11 @@ void RivTernarySaturationOverlayItem::renderGeneric( cvf::OpenGLContext* oglCont
 //--------------------------------------------------------------------------------------------------
 /// Draw the axis using immediate mode OpenGL
 //--------------------------------------------------------------------------------------------------
-void RivTernarySaturationOverlayItem::renderAxisImmediateMode(
+void RivTernarySaturationOverlayItem::renderAxisImmediateMode( float               upperBoundY,
-    float upperBoundY, float lowerBoundY, float border, unsigned int totalWidth, cvf::OpenGLContext* oglContext )
+                                                               float               lowerBoundY,
+                                                               float               border,
+                                                               unsigned int        totalWidth,
+                                                               cvf::OpenGLContext* oglContext )
 {
 #ifdef CVF_OPENGL_ES
     CVF_UNUSED( layout );

ApplicationCode/ModelVisualization/RivTernarySaturationOverlayItem.h

@@ -51,8 +51,11 @@ private:
     void renderSoftware( cvf::OpenGLContext* oglContext, const cvf::Vec2i& position, const cvf::Vec2ui& size ) override;
 
     void renderGeneric( cvf::OpenGLContext* oglContext, const cvf::Vec2i& position, const cvf::Vec2ui& size, bool software );
-    void renderAxisImmediateMode(
+    void renderAxisImmediateMode( float               upperY,
-        float upperY, float lowerBoundY, float border, unsigned int totalWidth, cvf::OpenGLContext* oglContext );
+                                  float               lowerBoundY,
+                                  float               border,
+                                  unsigned int        totalWidth,
+                                  cvf::OpenGLContext* oglContext );
 
 private:
     cvf::String m_soilRange;

ApplicationCode/ModelVisualization/RivWellConnectionFactorGeometryGenerator.cpp

@@ -31,7 +31,8 @@
 ///
 //--------------------------------------------------------------------------------------------------
 RivWellConnectionFactorGeometryGenerator::RivWellConnectionFactorGeometryGenerator(
-    std::vector<CompletionVizData>& completionVizData, float radius )
+    std::vector<CompletionVizData>& completionVizData,
+    float                           radius )
     : m_completionVizData( completionVizData )
     , m_radius( radius )
     , m_trianglesPerConnection( 0 )

ApplicationCode/ModelVisualization/RivWellFracturePartMgr.h

@@ -89,8 +89,10 @@ private:
                                                        RimFracture*             fracture,
                                                        bool                     disableLighting );
 
-    static std::vector<cvf::Vec3f> transformToFractureDisplayCoords(
+    static std::vector<cvf::Vec3f>
-        const std::vector<cvf::Vec3f>& polygon, cvf::Mat4d m, const caf::DisplayCoordTransform& displayCoordTransform );
+        transformToFractureDisplayCoords( const std::vector<cvf::Vec3f>&    polygon,
+                                          cvf::Mat4d                        m,
+                                          const caf::DisplayCoordTransform& displayCoordTransform );
 
     static cvf::ref<cvf::DrawableGeo> buildDrawableGeoFromTriangles( const std::vector<cvf::uint>&  triangleIndices,
                                                                      const std::vector<cvf::Vec3f>& nodeCoords );

ApplicationCode/ProjectDataModel/Completions/RimStimPlanFractureTemplate.cpp

@@ -924,8 +924,11 @@ bool RimStimPlanFractureTemplate::hasConductivity() const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RimStimPlanFractureTemplate::resultValueAtIJ(
+double RimStimPlanFractureTemplate::resultValueAtIJ( const QString& uiResultName,
-    const QString& uiResultName, const QString& unitName, size_t timeStepIndex, size_t i, size_t j )
+                                                     const QString& unitName,
+                                                     size_t         timeStepIndex,
+                                                     size_t         i,
+                                                     size_t         j )
 {
     auto values = resultValues( uiResultName, unitName, timeStepIndex );
 

ApplicationCode/ProjectDataModel/PlotTemplates/RimPlotTemplateFolderItem.cpp

@@ -191,8 +191,9 @@ void RimPlotTemplateFolderItem::defineEditorAttribute( const caf::PdmFieldHandle
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimPlotTemplateFolderItem::appendOptionItemsForPlotTemplatesRecursively(
+void RimPlotTemplateFolderItem::appendOptionItemsForPlotTemplatesRecursively( QList<caf::PdmOptionItemInfo>& options,
-    QList<caf::PdmOptionItemInfo>& options, RimPlotTemplateFolderItem* templateFolderItem, int menuLevel )
+                                                                              RimPlotTemplateFolderItem* templateFolderItem,
+                                                                              int                        menuLevel )
 {
     {
         auto subFolders = templateFolderItem->subFolders();

ApplicationCode/ProjectDataModel/RimContourMapProjection.cpp

@@ -1160,7 +1160,8 @@ void RimContourMapProjection::generateContourPolygons()
 ///
 //--------------------------------------------------------------------------------------------------
 RimContourMapProjection::ContourPolygons RimContourMapProjection::createContourPolygonsFromLineSegments(
-    caf::ContourLines::ListOfLineSegments& unorderedLineSegments, double contourValue )
+    caf::ContourLines::ListOfLineSegments& unorderedLineSegments,
+    double                                 contourValue )
 {
     const double areaThreshold = 1.5 * ( m_sampleSpacing * m_sampleSpacing ) /
                                  ( sampleSpacingFactor() * sampleSpacingFactor() );

ApplicationCode/ProjectDataModel/RimEclipseGeometrySelectionItem.cpp

@@ -67,8 +67,11 @@ void RimEclipseGeometrySelectionItem::setFromSelectionItem( const RiuEclipseSele
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimEclipseGeometrySelectionItem::setFromCaseGridAndIJK(
+void RimEclipseGeometrySelectionItem::setFromCaseGridAndIJK( RimEclipseCase* eclipseCase,
-    RimEclipseCase* eclipseCase, size_t gridIndex, size_t i, size_t j, size_t k )
+                                                             size_t          gridIndex,
+                                                             size_t          i,
+                                                             size_t          j,
+                                                             size_t          k )
 {
     m_eclipseCase = eclipseCase;
     m_gridIndex   = gridIndex;

ApplicationCode/ProjectDataModel/RimGeoMechResultDefinition.cpp

@@ -405,7 +405,9 @@ std::map<std::string, std::vector<std::string>> RimGeoMechResultDefinition::getR
 ///
 //--------------------------------------------------------------------------------------------------
 void RimGeoMechResultDefinition::getUiAndResultVariableStringList(
-    QStringList* uiNames, QStringList* variableNames, const std::map<std::string, std::vector<std::string>>& fieldCompNames )
+    QStringList*                                           uiNames,
+    QStringList*                                           variableNames,
+    const std::map<std::string, std::vector<std::string>>& fieldCompNames )
 {
     CVF_ASSERT( uiNames && variableNames );
 

ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.cpp

@@ -154,8 +154,12 @@ void RimGridTimeHistoryCurve::setFromSelectionItem( const RiuSelectionItem* sele
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimGridTimeHistoryCurve::setFromEclipseCellAndResult(
+void RimGridTimeHistoryCurve::setFromEclipseCellAndResult( RimEclipseCase*                eclCase,
-    RimEclipseCase* eclCase, size_t gridIdx, size_t i, size_t j, size_t k, const RigEclipseResultAddress& resAddr )
+                                                           size_t                         gridIdx,
+                                                           size_t                         i,
+                                                           size_t                         j,
+                                                           size_t                         k,
+                                                           const RigEclipseResultAddress& resAddr )
 {
     delete m_geometrySelectionItem();
     delete m_eclipseResultDefinition();

ApplicationCode/ProjectDataModel/RimGridTimeHistoryCurve.h

@@ -53,9 +53,13 @@ public:
     RimGridTimeHistoryCurve();
     ~RimGridTimeHistoryCurve() override;
 
-    void setFromSelectionItem( const RiuSelectionItem* selectionItem );
+    void                 setFromSelectionItem( const RiuSelectionItem* selectionItem );
-    void setFromEclipseCellAndResult(
+    void                 setFromEclipseCellAndResult( RimEclipseCase*                eclCase,
-        RimEclipseCase* eclCase, size_t gridIdx, size_t i, size_t j, size_t k, const RigEclipseResultAddress& resAddr );
+                                                      size_t                         gridIdx,
+                                                      size_t                         i,
+                                                      size_t                         j,
+                                                      size_t                         k,
+                                                      const RigEclipseResultAddress& resAddr );
     RiaDefines::PlotAxis yAxis() const;
     void                 setYAxis( RiaDefines::PlotAxis plotAxis );
 

ApplicationCode/ProjectDataModel/RimObservedDataCollection.cpp

@@ -165,8 +165,10 @@ RimObservedSummaryData*
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RimObservedSummaryData* RimObservedDataCollection::createAndAddCvsObservedSummaryDataFromFile(
+RimObservedSummaryData*
-    const QString& fileName, bool useSavedFieldsValuesInDialog, QString* errorText /*= nullptr*/ )
+    RimObservedDataCollection::createAndAddCvsObservedSummaryDataFromFile( const QString& fileName,
+                                                                           bool           useSavedFieldsValuesInDialog,
+                                                                           QString*       errorText /*= nullptr*/ )
 {
     if ( !fileExists( fileName, errorText ) ) return nullptr;
 

ApplicationCode/ProjectDataModel/RimTernaryLegendConfig.cpp

@@ -214,8 +214,11 @@ void RimTernaryLegendConfig::updateLegend()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimTernaryLegendConfig::setAutomaticRanges(
+void RimTernaryLegendConfig::setAutomaticRanges( TernaryArrayIndex ternaryIndex,
-    TernaryArrayIndex ternaryIndex, double globalMin, double globalMax, double localMin, double localMax )
+                                                 double            globalMin,
+                                                 double            globalMax,
+                                                 double            localMin,
+                                                 double            localMax )
 {
     double candidateGlobalAutoMin = roundToNumSignificantDigits( globalMin, precision );
     double candidateGlobalAutoMax = roundToNumSignificantDigits( globalMax, precision );
@@ -379,8 +382,12 @@ void RimTernaryLegendConfig::defineEditorAttribute( const caf::PdmFieldHandle* f
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimTernaryLegendConfig::ternaryRanges(
+void RimTernaryLegendConfig::ternaryRanges( double& soilLower,
-    double& soilLower, double& soilUpper, double& sgasLower, double& sgasUpper, double& swatLower, double& swatUpper ) const
+                                            double& soilUpper,
+                                            double& sgasLower,
+                                            double& sgasUpper,
+                                            double& swatLower,
+                                            double& swatUpper ) const
 {
     if ( rangeMode() == AUTOMATIC_CURRENT_TIMESTEP )
     {

ApplicationCode/ProjectDataModel/RimTernaryLegendConfig.h

@@ -55,8 +55,11 @@ public:
     ~RimTernaryLegendConfig() override;
 
     void setUiValuesFromLegendConfig( const RimTernaryLegendConfig* otherLegendConfig );
-    void setAutomaticRanges(
+    void setAutomaticRanges( TernaryArrayIndex ternaryIndex,
-        TernaryArrayIndex ternaryIndex, double globalMin, double globalMax, double localMin, double localMax );
+                             double            globalMin,
+                             double            globalMax,
+                             double            localMin,
+                             double            localMax );
 
     void                           recreateLegend();
     bool                           showLegend() const;

ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp

@@ -576,8 +576,11 @@ void RimWellLogExtractionCurve::findAndLoadWbsParametersFromLasFiles( const RimW
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RimWellLogExtractionCurve::setAutoNameComponents(
+void RimWellLogExtractionCurve::setAutoNameComponents( bool addCaseName,
-    bool addCaseName, bool addProperty, bool addWellname, bool addTimeStep, bool addDate )
+                                                       bool addProperty,
+                                                       bool addWellname,
+                                                       bool addTimeStep,
+                                                       bool addDate )
 {
     m_addCaseNameToCurveName = addCaseName;
     m_addPropertyToCurveName = addProperty;

ApplicationCode/ProjectDataModel/Summary/RimSummaryCaseMainCollection.cpp

@@ -376,7 +376,8 @@ RimSummaryCaseCollection* RimSummaryCaseMainCollection::defaultAllocator()
 ///
 //--------------------------------------------------------------------------------------------------
 std::vector<RimSummaryCase*> RimSummaryCaseMainCollection::createSummaryCasesFromFileInfos(
-    const std::vector<RifSummaryCaseFileResultInfo>& summaryHeaderFileInfos, bool showProgress )
+    const std::vector<RifSummaryCaseFileResultInfo>& summaryHeaderFileInfos,
+    bool                                             showProgress )
 {
     RimProject* project = RiaApplication::instance()->project();
 

ApplicationCode/ReservoirDataModel/Completions/RigCompletionData.cpp

@@ -166,8 +166,11 @@ void RigCompletionData::setTransmissibility( double transmissibility )
 //==================================================================================================
 ///
 //==================================================================================================
-void RigCompletionData::setTransAndWPImultBackgroundDataFromFishbone(
+void RigCompletionData::setTransAndWPImultBackgroundDataFromFishbone( double        transmissibility,
-    double transmissibility, double skinFactor, double diameter, CellDirection direction, bool isMainBore )
+                                                                      double        skinFactor,
+                                                                      double        diameter,
+                                                                      CellDirection direction,
+                                                                      bool          isMainBore )
 {
     m_completionType   = FISHBONES;
     m_transmissibility = transmissibility;
@@ -180,8 +183,12 @@ void RigCompletionData::setTransAndWPImultBackgroundDataFromFishbone(
 //==================================================================================================
 ///
 //==================================================================================================
-void RigCompletionData::setTransAndWPImultBackgroundDataFromPerforation(
+void RigCompletionData::setTransAndWPImultBackgroundDataFromPerforation( double        transmissibility,
-    double transmissibility, double skinFactor, double diameter, double dFactor, double kh, CellDirection direction )
+                                                                         double        skinFactor,
+                                                                         double        diameter,
+                                                                         double        dFactor,
+                                                                         double        kh,
+                                                                         CellDirection direction )
 {
     m_completionType   = PERFORATION;
     m_transmissibility = transmissibility;
@@ -212,8 +219,11 @@ void RigCompletionData::setCombinedValuesExplicitTrans( double         transmiss
 //==================================================================================================
 ///
 //==================================================================================================
-void RigCompletionData::setCombinedValuesImplicitTransWPImult(
+void RigCompletionData::setCombinedValuesImplicitTransWPImult( double         wpimult,
-    double wpimult, double skinFactor, double diameter, CellDirection celldirection, CompletionType completionType )
+                                                               double         skinFactor,
+                                                               double         diameter,
+                                                               CellDirection  celldirection,
+                                                               CompletionType completionType )
 {
     m_wpimult        = wpimult;
     m_direction      = celldirection;

ApplicationCode/ReservoirDataModel/Completions/RigCompletionData.h

@@ -98,11 +98,18 @@ public:
     void setDiameter( double diameter );
     void setTransmissibility( double transmissibility );
 
-    void setTransAndWPImultBackgroundDataFromFishbone(
+    void setTransAndWPImultBackgroundDataFromFishbone( double        transmissibility,
-        double transmissibility, double skinFactor, double diameter, CellDirection direction, bool isMainBore );
+                                                       double        skinFactor,
+                                                       double        diameter,
+                                                       CellDirection direction,
+                                                       bool          isMainBore );
 
-    void setTransAndWPImultBackgroundDataFromPerforation(
+    void setTransAndWPImultBackgroundDataFromPerforation( double        transmissibility,
-        double transmissibility, double skinFactor, double diameter, double dFactor, double kh, CellDirection direction );
+                                                          double        skinFactor,
+                                                          double        diameter,
+                                                          double        dFactor,
+                                                          double        kh,
+                                                          CellDirection direction );
 
     void setCombinedValuesExplicitTrans( double         transmissibility,
                                          double         skinFactor,
@@ -110,8 +117,11 @@ public:
                                          CellDirection  celldirection,
                                          CompletionType completionType );
 
-    void setCombinedValuesImplicitTransWPImult(
+    void setCombinedValuesImplicitTransWPImult( double         wpimult,
-        double wpimult, double skinFactor, double diameter, CellDirection celldirection, CompletionType completionType );
+                                                double         skinFactor,
+                                                double         diameter,
+                                                CellDirection  celldirection,
+                                                CompletionType completionType );
 
     bool isNonDarcyFlow() const;
     void setDFactor( double dFactor );

ApplicationCode/ReservoirDataModel/Completions/RigFractureTransmissibilityEquations.cpp

@@ -154,8 +154,8 @@ double RigFractureTransmissibilityEquations::matrixToFractureTrans( double perm,
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-double RigFractureTransmissibilityEquations::effectiveInternalFractureToWellTransPDDHC(
+double RigFractureTransmissibilityEquations::effectiveInternalFractureToWellTransPDDHC( double sumScaledMatrixToFractureTrans,
-    double sumScaledMatrixToFractureTrans, double scaledMatrixToWellTrans )
+                                                                                        double scaledMatrixToWellTrans )
 {
     double divisor = sumScaledMatrixToFractureTrans - scaledMatrixToWellTrans;
     if ( cvf::Math::abs( divisor ) > EPSILON )

ApplicationCode/ReservoirDataModel/Completions/RigVirtualPerforationTransmissibilities.cpp

@@ -68,7 +68,8 @@ RigVirtualPerforationTransmissibilities::~RigVirtualPerforationTransmissibilitie
 ///
 //--------------------------------------------------------------------------------------------------
 void RigVirtualPerforationTransmissibilities::setCompletionDataForWellPath(
-    const RimWellPath* wellPath, const std::vector<std::vector<RigCompletionData>>& completionsPerTimeStep )
+    const RimWellPath*                                 wellPath,
+    const std::vector<std::vector<RigCompletionData>>& completionsPerTimeStep )
 {
     auto item = m_mapFromWellToCompletionData.find( wellPath );
 
@@ -118,7 +119,8 @@ const std::map<size_t, std::vector<RigCompletionData>>&
 ///
 //--------------------------------------------------------------------------------------------------
 void RigVirtualPerforationTransmissibilities::setCompletionDataForSimWell(
-    const RigSimWellData* simWellData, const std::vector<std::vector<RigCompletionData>>& completionsPerTimeStep )
+    const RigSimWellData*                              simWellData,
+    const std::vector<std::vector<RigCompletionData>>& completionsPerTimeStep )
 {
     m_mapFromSimWellToCompletionData[simWellData] = completionsPerTimeStep;
 }

ApplicationCode/ReservoirDataModel/RigAccWellFlowCalculator.cpp

@@ -676,8 +676,9 @@ std::vector<double> RigAccWellFlowCalculator::accumulatedDsBranchFlowPrTracer( c
 //--------------------------------------------------------------------------------------------------
 /// Calculate the flow pr tracer. If inconsistent flow, keep the existing fractions constant
 //--------------------------------------------------------------------------------------------------
-std::vector<double> RigAccWellFlowCalculator::calculateWellCellFlowPrTracer(
+std::vector<double>
-    const RigWellResultPoint& wellCell, const std::vector<double>& currentAccumulatedFlowPrTracer ) const
+    RigAccWellFlowCalculator::calculateWellCellFlowPrTracer( const RigWellResultPoint& wellCell,
+                                                             const std::vector<double>& currentAccumulatedFlowPrTracer ) const
 {
     std::vector<double> flowPrTracer( m_tracerNames.size(), 0.0 );
 

ApplicationCode/ReservoirDataModel/RigCaseCellResultsData.cpp

@@ -1067,8 +1067,8 @@ bool RigCaseCellResultsData::ensureKnownResultLoaded( const RigEclipseResultAddr
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RigCaseCellResultsData::findAndLoadResultByName(
+bool RigCaseCellResultsData::findAndLoadResultByName( const QString&                                resultName,
-    const QString& resultName, const std::vector<RiaDefines::ResultCatType>& resultCategorySearchOrder )
+                                                      const std::vector<RiaDefines::ResultCatType>& resultCategorySearchOrder )
 {
     RigEclipseResultAddress adr( resultName );
 
@@ -1368,7 +1368,8 @@ size_t RigCaseCellResultsData::findOrLoadKnownScalarResult( const RigEclipseResu
 ///
 //--------------------------------------------------------------------------------------------------
 size_t RigCaseCellResultsData::findOrLoadKnownScalarResultByResultTypeOrder(
-    const RigEclipseResultAddress& resVarAddr, const std::vector<RiaDefines::ResultCatType>& resultCategorySearchOrder )
+    const RigEclipseResultAddress&                resVarAddr,
+    const std::vector<RiaDefines::ResultCatType>& resultCategorySearchOrder )
 {
     std::set<RiaDefines::ResultCatType> otherResultTypesToSearch = {RiaDefines::STATIC_NATIVE,
                                                                     RiaDefines::DYNAMIC_NATIVE,

ApplicationCode/ReservoirDataModel/RigEclipseResultInfo.cpp

@@ -33,8 +33,10 @@ RigEclipseTimeStepInfo::RigEclipseTimeStepInfo( const QDateTime& date, int repor
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<RigEclipseTimeStepInfo> RigEclipseTimeStepInfo::createTimeStepInfos(
+std::vector<RigEclipseTimeStepInfo>
-    std::vector<QDateTime> dates, std::vector<int> reportNumbers, std::vector<double> daysSinceSimulationStarts )
+    RigEclipseTimeStepInfo::createTimeStepInfos( std::vector<QDateTime> dates,
+                                                 std::vector<int>       reportNumbers,
+                                                 std::vector<double>    daysSinceSimulationStarts )
 {
     CVF_ASSERT( dates.size() == reportNumbers.size() );
     CVF_ASSERT( dates.size() == daysSinceSimulationStarts.size() );

ApplicationCode/ReservoirDataModel/RigFlowDiagInterfaceTools.h

@@ -88,8 +88,10 @@ inline Opm::FlowDiagnostics::ConnectionValues
     return flux;
 }
 
-inline Opm::FlowDiagnostics::ConnectionValues extractFluxFieldFromRestartFile(
+inline Opm::FlowDiagnostics::ConnectionValues
-    const Opm::ECLGraph& G, const Opm::ECLRestartData& rstrt, RigFlowDiagResultAddress::PhaseSelection phaseSelection )
+    extractFluxFieldFromRestartFile( const Opm::ECLGraph&                     G,
+                                     const Opm::ECLRestartData&               rstrt,
+                                     RigFlowDiagResultAddress::PhaseSelection phaseSelection )
 {
     auto getFlux = [&G, &rstrt]( const Opm::ECLPhaseIndex p ) { return G.flux( rstrt, p ); };
 

ApplicationCode/ReservoirDataModel/RigFlowDiagResults.cpp

@@ -112,7 +112,8 @@ const std::vector<double>* RigFlowDiagResults::findOrCalculateResult( const RigF
 ///
 //--------------------------------------------------------------------------------------------------
 void RigFlowDiagResults::calculateNativeResultsIfNotPreviouslyAttempted(
-    size_t timeStepIndex, RigFlowDiagResultAddress::PhaseSelection phaseSelection )
+    size_t                                   timeStepIndex,
+    RigFlowDiagResultAddress::PhaseSelection phaseSelection )
 {
     if ( timeStepIndex >= m_hasAtemptedNativeResults.size() ) return;
 
@@ -899,8 +900,10 @@ RigFlowDiagSolverInterface::FlowCharacteristicsResultFrame
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RigFlowDiagSolverInterface::FlowCharacteristicsResultFrame RigFlowDiagResults::flowCharacteristicsResults(
+RigFlowDiagSolverInterface::FlowCharacteristicsResultFrame
-    int timeStepIndex, const std::vector<char>& visibleActiveCells, double max_pv_fraction )
+    RigFlowDiagResults::flowCharacteristicsResults( int                      timeStepIndex,
+                                                    const std::vector<char>& visibleActiveCells,
+                                                    double                   max_pv_fraction )
 {
     std::vector<QString> tracerNames = m_flowDiagSolution->tracerNames();
 

ApplicationCode/ReservoirDataModel/RigFlowDiagResults.h

@@ -101,8 +101,10 @@ public:
                                     double                      minCommunication,
                                     int                         maxTof );
 
-    RigFlowDiagSolverInterface::FlowCharacteristicsResultFrame flowCharacteristicsResults(
+    RigFlowDiagSolverInterface::FlowCharacteristicsResultFrame
-        int timeStepIndex, const std::vector<char>& visibleActiveCells, double max_pv_fraction );
+        flowCharacteristicsResults( int                      timeStepIndex,
+                                    const std::vector<char>& visibleActiveCells,
+                                    double                   max_pv_fraction );
 
     RimFlowDiagSolution* flowDiagSolution();
 

ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.cpp

@@ -864,8 +864,12 @@ std::vector<RigFlowDiagSolverInterface::PvtCurve>
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RigFlowDiagSolverInterface::calculatePvtDynamicPropertiesFvf(
+bool RigFlowDiagSolverInterface::calculatePvtDynamicPropertiesFvf( size_t  activeCellIndex,
-    size_t activeCellIndex, double pressure, double rs, double rv, double* bo, double* bg )
+                                                                   double  pressure,
+                                                                   double  rs,
+                                                                   double  rv,
+                                                                   double* bo,
+                                                                   double* bg )
 {
     if ( bo ) *bo = HUGE_VAL;
     if ( bg ) *bg = HUGE_VAL;
@@ -927,8 +931,12 @@ bool RigFlowDiagSolverInterface::calculatePvtDynamicPropertiesFvf(
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RigFlowDiagSolverInterface::calculatePvtDynamicPropertiesViscosity(
+bool RigFlowDiagSolverInterface::calculatePvtDynamicPropertiesViscosity( size_t  activeCellIndex,
-    size_t activeCellIndex, double pressure, double rs, double rv, double* mu_o, double* mu_g )
+                                                                         double  pressure,
+                                                                         double  rs,
+                                                                         double  rv,
+                                                                         double* mu_o,
+                                                                         double* mu_g )
 {
     if ( mu_o ) *mu_o = HUGE_VAL;
     if ( mu_g ) *mu_g = HUGE_VAL;

ApplicationCode/ReservoirDataModel/RigFlowDiagSolverInterface.h

@@ -151,10 +151,18 @@ public:
 
     std::vector<RelPermCurve> calculateRelPermCurves( size_t activeCellIndex );
     std::vector<PvtCurve>     calculatePvtCurves( PvtCurveType pvtCurveType, size_t activeCellIndex );
-    bool                      calculatePvtDynamicPropertiesFvf(
+    bool                      calculatePvtDynamicPropertiesFvf( size_t  activeCellIndex,
-                             size_t activeCellIndex, double pressure, double rs, double rv, double* bo, double* bg );
+                                                                double  pressure,
-    bool calculatePvtDynamicPropertiesViscosity(
+                                                                double  rs,
-        size_t activeCellIndex, double pressure, double rs, double rv, double* mu_o, double* mu_g );
+                                                                double  rv,
+                                                                double* bo,
+                                                                double* bg );
+    bool                      calculatePvtDynamicPropertiesViscosity( size_t  activeCellIndex,
+                                                                      double  pressure,
+                                                                      double  rs,
+                                                                      double  rv,
+                                                                      double* mu_o,
+                                                                      double* mu_g );
 
 private:
     std::wstring getInitFileName() const;

ApplicationCode/ReservoirDataModel/RigGridBase.cpp

@@ -404,8 +404,13 @@ size_t RigGridBase::addCoarseningBox( size_t i1, size_t i2, size_t j1, size_t j2
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RigGridBase::coarseningBox(
+void RigGridBase::coarseningBox( size_t  coarseningBoxIndex,
-    size_t coarseningBoxIndex, size_t* i1, size_t* i2, size_t* j1, size_t* j2, size_t* k1, size_t* k2 ) const
+                                 size_t* i1,
+                                 size_t* i2,
+                                 size_t* j1,
+                                 size_t* j2,
+                                 size_t* k1,
+                                 size_t* k2 ) const
 {
     CVF_ASSERT( coarseningBoxIndex < m_coarseningBoxInfo.size() );
 
@@ -446,8 +451,11 @@ cvf::BoundingBox RigGridBase::boundingBox()
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-bool RigGridCellFaceVisibilityFilter::isFaceVisible(
+bool RigGridCellFaceVisibilityFilter::isFaceVisible( size_t                             i,
-    size_t i, size_t j, size_t k, cvf::StructGridInterface::FaceType face, const cvf::UByteArray* cellVisibility ) const
+                                                     size_t                             j,
+                                                     size_t                             k,
+                                                     cvf::StructGridInterface::FaceType face,
+                                                     const cvf::UByteArray*             cellVisibility ) const
 {
     CVF_TIGHT_ASSERT( m_grid );
 

ApplicationCode/ReservoirDataModel/RigGridBase.h

@@ -98,8 +98,8 @@ public:
     }
     size_t addCoarseningBox( size_t i1, size_t i2, size_t j1, size_t j2, size_t k1, size_t k2 );
 
-    void coarseningBox(
+    void coarseningBox( size_t coarseningBoxIndex, size_t* i1, size_t* i2, size_t* j1, size_t* j2, size_t* k1, size_t* k2 )
-        size_t coarseningBoxIndex, size_t* i1, size_t* i2, size_t* j1, size_t* j2, size_t* k1, size_t* k2 ) const;
+        const;
 
     cvf::BoundingBox boundingBox();
 

ApplicationCode/ReservoirDataModel/RigStimPlanFractureDefinition.cpp

@@ -279,8 +279,10 @@ std::vector<std::pair<QString, QString>> RigStimPlanFractureDefinition::getStimP
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<std::vector<double>> RigStimPlanFractureDefinition::conductivityValuesAtTimeStep(
+std::vector<std::vector<double>>
-    const QString& resultName, int activeTimeStepIndex, RiaEclipseUnitTools::UnitSystem requiredUnitSet ) const
+    RigStimPlanFractureDefinition::conductivityValuesAtTimeStep( const QString&                  resultName,
+                                                                 int                             activeTimeStepIndex,
+                                                                 RiaEclipseUnitTools::UnitSystem requiredUnitSet ) const
 {
     std::vector<std::vector<double>> conductivityValues;
 

ApplicationCode/ReservoirDataModel/RigWellPath.h

@@ -56,8 +56,10 @@ public:
     double wellPathAzimuthAngle( const cvf::Vec3d& position ) const;
     void   twoClosestPoints( const cvf::Vec3d& position, cvf::Vec3d* p1, cvf::Vec3d* p2 ) const;
 
-    std::pair<std::vector<cvf::Vec3d>, std::vector<double>> clippedPointSubset(
+    std::pair<std::vector<cvf::Vec3d>, std::vector<double>>
-        double startMD, double endMD, double* horizontalLengthAlongWellToStartClipPoint = nullptr ) const;
+        clippedPointSubset( double  startMD,
+                            double  endMD,
+                            double* horizontalLengthAlongWellToStartClipPoint = nullptr ) const;
 
     std::vector<cvf::Vec3d> wellPathPointsIncludingInterpolatedIntersectionPoint( double intersectionMeasuredDepth ) const;
 

ApplicationCode/ReservoirDataModel/RigWellPathIntersectionTools.cpp

@@ -33,8 +33,10 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-std::vector<WellPathCellIntersectionInfo> RigWellPathIntersectionTools::findCellIntersectionInfosAlongPath(
+std::vector<WellPathCellIntersectionInfo>
-    const RigEclipseCaseData* caseData, const std::vector<cvf::Vec3d>& pathCoords, const std::vector<double>& pathMds )
+    RigWellPathIntersectionTools::findCellIntersectionInfosAlongPath( const RigEclipseCaseData*      caseData,
+                                                                      const std::vector<cvf::Vec3d>& pathCoords,
+                                                                      const std::vector<double>&     pathMds )
 {
     std::vector<WellPathCellIntersectionInfo> intersectionInfos;
 

ApplicationCode/ReservoirDataModel/cvfGeometryTools.cpp

@@ -636,8 +636,11 @@ inline double triArea3D( const cvf::Vec3d& v0, const cvf::Vec3d& v1, const cvf::
 /// a_i = Area(v_(i-1), v_i, v_(i+1))*Area(p, v_(i-2), v_(i-1))*Area(p, v_(i+1), v_(i+2))
 
 //--------------------------------------------------------------------------------------------------
-cvf::Vec4d GeometryTools::barycentricCoords(
+cvf::Vec4d GeometryTools::barycentricCoords( const cvf::Vec3d& v0,
-    const cvf::Vec3d& v0, const cvf::Vec3d& v1, const cvf::Vec3d& v2, const cvf::Vec3d& v3, const cvf::Vec3d& p )
+                                             const cvf::Vec3d& v1,
+                                             const cvf::Vec3d& v2,
+                                             const cvf::Vec3d& v3,
+                                             const cvf::Vec3d& p )
 {
     cvf::Vec4d w;
     cvf::Vec4d a;

ApplicationCode/ReservoirDataModel/cvfGeometryTools.h

@@ -53,8 +53,11 @@ public:
                                                 bool*            isLineDirDotNormalNegative );
     static cvf::Vec3d
                       barycentricCoords( const cvf::Vec3d& t0, const cvf::Vec3d& t1, const cvf::Vec3d& t2, const cvf::Vec3d& p );
-    static cvf::Vec4d barycentricCoords(
+    static cvf::Vec4d barycentricCoords( const cvf::Vec3d& v0,
-        const cvf::Vec3d& v0, const cvf::Vec3d& v1, const cvf::Vec3d& v2, const cvf::Vec3d& v3, const cvf::Vec3d& p );
+                                         const cvf::Vec3d& v1,
+                                         const cvf::Vec3d& v2,
+                                         const cvf::Vec3d& v3,
+                                         const cvf::Vec3d& p );
     template <typename DataType>
     static DataType interpolateQuad( const cvf::Vec3d& v1,
                                      DataType          s1,
@@ -163,8 +166,13 @@ private:
         double                            fractionAlongEdge2;
     };
 
-    void canonizeAddress(
+    void canonizeAddress( IndexType& e1P1,
-        IndexType& e1P1, IndexType& e1P2, IndexType& e2P1, IndexType& e2P2, bool& flipE1, bool& flipE2, bool& flipE1E2 );
+                          IndexType& e1P2,
+                          IndexType& e2P1,
+                          IndexType& e2P2,
+                          bool&      flipE1,
+                          bool&      flipE2,
+                          bool&      flipE1E2 );
 
     // A map containing the intersection data. The addressing is :
     // ( when leastVxIdxEdge1 < leastVxIdxEdge2 )

ApplicationCode/ResultStatisticsCache/RigStatisticsMath.cpp

@@ -28,8 +28,13 @@
 /// A function to do basic statistical calculations
 //--------------------------------------------------------------------------------------------------
 
-void RigStatisticsMath::calculateBasicStatistics(
+void RigStatisticsMath::calculateBasicStatistics( const std::vector<double>& values,
-    const std::vector<double>& values, double* min, double* max, double* sum, double* range, double* mean, double* dev )
+                                                  double*                    min,
+                                                  double*                    max,
+                                                  double*                    sum,
+                                                  double*                    range,
+                                                  double*                    mean,
+                                                  double*                    dev )
 {
     double m_min( HUGE_VAL );
     double m_max( -HUGE_VAL );
@@ -82,8 +87,11 @@ void RigStatisticsMath::calculateBasicStatistics(
 /// Algorithm:
 /// https://en.wikipedia.org/wiki/Percentile#Third_variant,_'%22%60UNIQ--postMath-00000052-QINU%60%22'
 //--------------------------------------------------------------------------------------------------
-void RigStatisticsMath::calculateStatisticsCurves(
+void RigStatisticsMath::calculateStatisticsCurves( const std::vector<double>& values,
-    const std::vector<double>& values, double* p10, double* p50, double* p90, double* mean )
+                                                   double*                    p10,
+                                                   double*                    p50,
+                                                   double*                    p90,
+                                                   double*                    mean )
 {
     CVF_ASSERT( p10 && p50 && p90 && mean );
 

ApplicationCode/ResultStatisticsCache/RigStatisticsMath.h

@@ -34,8 +34,8 @@ public:
                                           double*                    range,
                                           double*                    mean,
                                           double*                    dev );
-    static void calculateStatisticsCurves(
+    static void
-        const std::vector<double>& values, double* p10, double* p50, double* p90, double* mean );
+        calculateStatisticsCurves( const std::vector<double>& values, double* p10, double* p50, double* p90, double* mean );
 
     static std::vector<double> calculateNearestRankPercentiles( const std::vector<double>& inputValues,
                                                                 const std::vector<double>& pValPositions );

ApplicationCode/SocketInterface/RiaSocketTools.cpp

@@ -70,8 +70,11 @@ RimEclipseCase* RiaSocketTools::findCaseFromArgs( RiaSocketServer* server, const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RiaSocketTools::getCaseInfoFromCase(
+void RiaSocketTools::getCaseInfoFromCase( RimCase* rimCase,
-    RimCase* rimCase, qint64& caseId, QString& caseName, QString& caseType, qint64& caseGroupId )
+                                          qint64&  caseId,
+                                          QString& caseName,
+                                          QString& caseType,
+                                          qint64&  caseGroupId )
 {
     CVF_ASSERT( rimCase );
 

ApplicationCode/UserInterface/RiuFlowCharacteristicsPlot.cpp

@@ -187,8 +187,11 @@ void RiuFlowCharacteristicsPlot::setLorenzCurve( const QStringList&            d
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RiuFlowCharacteristicsPlot::addCurveWithLargeSymbol(
+void RiuFlowCharacteristicsPlot::addCurveWithLargeSymbol( QwtPlot*         plot,
-    QwtPlot* plot, const QString& curveName, const QColor& color, const QDateTime& dateTime, double timeHistoryValue )
+                                                          const QString&   curveName,
+                                                          const QColor&    color,
+                                                          const QDateTime& dateTime,
+                                                          double           timeHistoryValue )
 {
     auto curve = createEmptyCurve( plot, curveName, color );
 

ApplicationCode/UserInterface/RiuQwtPlotCurve.cpp

@@ -196,8 +196,13 @@ void RiuQwtPlotCurve::setSamplesFromTimeTAndYValues( const std::vector<time_t>&
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RiuQwtPlotCurve::drawCurve(
+void RiuQwtPlotCurve::drawCurve( QPainter*          p,
-    QPainter* p, int style, const QwtScaleMap& xMap, const QwtScaleMap& yMap, const QRectF& canvasRect, int from, int to ) const
+                                 int                style,
+                                 const QwtScaleMap& xMap,
+                                 const QwtScaleMap& yMap,
+                                 const QRectF&      canvasRect,
+                                 int                from,
+                                 int                to ) const
 {
     size_t intervalCount = m_polyLineStartStopIndices.size();
     if ( intervalCount > 0 )

ApplicationCode/UserInterface/RiuQwtPlotWidget.cpp

@@ -125,8 +125,11 @@ int RiuQwtPlotWidget::axisValueFontSize( QwtPlot::Axis axis ) const
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RiuQwtPlotWidget::setAxisFontsAndAlignment(
+void RiuQwtPlotWidget::setAxisFontsAndAlignment( QwtPlot::Axis     axis,
-    QwtPlot::Axis axis, int titleFontSize, int valueFontSize, bool titleBold, Qt::AlignmentFlag alignment )
+                                                 int               titleFontSize,
+                                                 int               valueFontSize,
+                                                 bool              titleBold,
+                                                 Qt::AlignmentFlag alignment )
 {
     // Axis number font
     QFont axisFont = this->axisFont( axis );
@@ -279,8 +282,11 @@ void RiuQwtPlotWidget::enableGridLines( QwtPlot::Axis axis, bool majorGridLines,
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RiuQwtPlotWidget::setMajorAndMinorTickIntervals(
+void RiuQwtPlotWidget::setMajorAndMinorTickIntervals( QwtPlot::Axis axis,
-    QwtPlot::Axis axis, double majorTickInterval, double minorTickInterval, double minValue, double maxValue )
+                                                      double        majorTickInterval,
+                                                      double        minorTickInterval,
+                                                      double        minValue,
+                                                      double        maxValue )
 {
     RiuQwtLinearScaleEngine* scaleEngine = dynamic_cast<RiuQwtLinearScaleEngine*>( this->axisScaleEngine( axis ) );
     if ( scaleEngine )

ApplicationCode/UserInterface/RiuQwtPlotWidget.h

@@ -83,8 +83,11 @@ public:
 
     void enableGridLines( QwtPlot::Axis axis, bool majorGridLines, bool minorGridLines );
 
-    void setMajorAndMinorTickIntervals(
+    void setMajorAndMinorTickIntervals( QwtPlot::Axis axis,
-        QwtPlot::Axis axis, double majorTickInterval, double minorTickInterval, double minValue, double maxValue );
+                                        double        majorTickInterval,
+                                        double        minorTickInterval,
+                                        double        minValue,
+                                        double        maxValue );
     void setAutoTickIntervalCounts( QwtPlot::Axis axis, int maxMajorTickIntervalCount, int maxMinorTickIntervalCount );
     double majorTickInterval( QwtPlot::Axis axis ) const;
     double minorTickInterval( QwtPlot::Axis axis ) const;

ApplicationCode/UserInterface/RiuRelativePermeabilityPlotPanel.cpp

@@ -576,8 +576,11 @@ QString RiuRelativePermeabilityPlotPanel::determineXAxisTitleFromCurveCollection
 //--------------------------------------------------------------------------------------------------
 /// Add a vertical labeled marker line at the specified saturation value
 //--------------------------------------------------------------------------------------------------
-void RiuRelativePermeabilityPlotPanel::addVerticalSaturationMarkerLine(
+void RiuRelativePermeabilityPlotPanel::addVerticalSaturationMarkerLine( double                       saturationValue,
-    double saturationValue, QString label, QColor color, QwtPlot* plot, std::vector<QwtPlotMarker*>* myPlotMarkers )
+                                                                        QString                      label,
+                                                                        QColor                       color,
+                                                                        QwtPlot*                     plot,
+                                                                        std::vector<QwtPlotMarker*>* myPlotMarkers )
 {
     QwtPlotMarker* lineMarker = new QwtPlotMarker;
     lineMarker->setXValue( saturationValue );

ApplicationCode/UserInterface/RiuRelativePermeabilityPlotPanel.h

@@ -92,8 +92,11 @@ private:
     static QString
         determineXAxisTitleFromCurveCollection( const std::vector<RigFlowDiagSolverInterface::RelPermCurve>& curveArr );
 
-    static void addVerticalSaturationMarkerLine(
+    static void addVerticalSaturationMarkerLine( double                       saturationValue,
-        double saturationValue, QString label, QColor color, QwtPlot* plot, std::vector<QwtPlotMarker*>* myPlotMarkers );
+                                                 QString                      label,
+                                                 QColor                       color,
+                                                 QwtPlot*                     plot,
+                                                 std::vector<QwtPlotMarker*>* myPlotMarkers );
 
     static void addCurveConstSaturationIntersectionMarker( const RigFlowDiagSolverInterface::RelPermCurve& curve,
                                                            double                       saturationValue,

ApplicationCode/UserInterface/RiuSummaryCurveDefSelection.cpp

@@ -1003,8 +1003,9 @@ std::set<RifEclipseSummaryAddress> RiuSummaryCurveDefSelection::findPossibleSumm
 //--------------------------------------------------------------------------------------------------
 /// Returns the summary addresses that match the selected item type and input selections made in GUI
 //--------------------------------------------------------------------------------------------------
-std::set<RifEclipseSummaryAddress> RiuSummaryCurveDefSelection::findPossibleSummaryAddresses(
+std::set<RifEclipseSummaryAddress>
-    const std::vector<SummarySource*>& selectedSources, const SummaryIdentifierAndField* identifierAndField ) const
+    RiuSummaryCurveDefSelection::findPossibleSummaryAddresses( const std::vector<SummarySource*>& selectedSources,
+                                                               const SummaryIdentifierAndField* identifierAndField ) const
 {
     std::set<RifEclipseSummaryAddress> addrUnion;
 
@@ -1126,7 +1127,8 @@ SummaryIdentifierAndField*
 ///
 //--------------------------------------------------------------------------------------------------
 bool RiuSummaryCurveDefSelection::isAddressCompatibleWithControllingFieldSelection(
-    const RifEclipseSummaryAddress& address, const std::vector<SummaryIdentifierAndField*>& identifierAndFieldList ) const
+    const RifEclipseSummaryAddress&                address,
+    const std::vector<SummaryIdentifierAndField*>& identifierAndFieldList ) const
 {
     for ( const auto& identifierAndField : identifierAndFieldList )
     {
@@ -1404,7 +1406,8 @@ void RiuSummaryCurveDefSelection::appendOptionItemsForCategories( QList<caf::Pdm
 ///
 //--------------------------------------------------------------------------------------------------
 void RiuSummaryCurveDefSelection::appendOptionItemsForSubCategoriesAndVectors(
-    QList<caf::PdmOptionItemInfo>& options, SummaryIdentifierAndField* identifierAndField ) const
+    QList<caf::PdmOptionItemInfo>& options,
+    SummaryIdentifierAndField*     identifierAndField ) const
 {
     if ( identifierAndField == nullptr ) return;
 

ApplicationCode/UserInterface/RiuSummaryCurveDefSelectionEditor.cpp

@@ -60,7 +60,8 @@ RiuSummaryCurveDefSelection* RiuSummaryCurveDefSelectionEditor::summaryAddressSe
 ///
 //--------------------------------------------------------------------------------------------------
 void RiuSummaryCurveDefSelectionEditor::recursivelyConfigureAndUpdateTopLevelUiOrdering(
-    const caf::PdmUiOrdering& topLevelUiOrdering, const QString& uiConfigName )
+    const caf::PdmUiOrdering& topLevelUiOrdering,
+    const QString&            uiConfigName )
 {
     if ( !m_firstRowLeftLayout || !m_firstRowRightLayout ) return;
 

ApplicationCode/UserInterface/RiuTofAccumulatedPhaseFractionsPlot.cpp

@@ -43,8 +43,8 @@
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-RiuTofAccumulatedPhaseFractionsPlot::RiuTofAccumulatedPhaseFractionsPlot(
+RiuTofAccumulatedPhaseFractionsPlot::RiuTofAccumulatedPhaseFractionsPlot( RimTofAccumulatedPhaseFractionsPlot* plotDefinition,
-    RimTofAccumulatedPhaseFractionsPlot* plotDefinition, QWidget* parent )
+                                                                          QWidget*                             parent )
     : QwtPlot( parent )
     , m_watCurve( nullptr )
     , m_oilCurve( nullptr )

ApplicationCode/UserInterface/RiuViewerCommands.cpp

@@ -1271,8 +1271,12 @@ void RiuViewerCommands::findFirstItems( Rim3dView*                          main
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-void RiuViewerCommands::ijkFromCellIndex(
+void RiuViewerCommands::ijkFromCellIndex( Rim3dView* mainOrComparisonView,
-    Rim3dView* mainOrComparisonView, size_t gridIdx, size_t cellIndex, size_t* i, size_t* j, size_t* k )
+                                          size_t     gridIdx,
+                                          size_t     cellIndex,
+                                          size_t*    i,
+                                          size_t*    j,
+                                          size_t*    k )
 {
     RimEclipseView* eclipseView = dynamic_cast<RimEclipseView*>( mainOrComparisonView );
     RimGeoMechView* geomView    = dynamic_cast<RimGeoMechView*>( mainOrComparisonView );

ApplicationCode/UserInterface/RiuViewerCommands.h

@@ -80,8 +80,12 @@ private:
                                cvf::uint                           firstPartTriangleIndex,
                                size_t*                             cellIndex,
                                size_t*                             gridIndex );
-    void ijkFromCellIndex(
+    void ijkFromCellIndex( Rim3dView* mainOrComparisonView,
-        Rim3dView* mainOrComparisonView, size_t gridIdx, size_t cellIndex, size_t* i, size_t* j, size_t* k );
+                           size_t     gridIdx,
+                           size_t     cellIndex,
+                           size_t*    i,
+                           size_t*    j,
+                           size_t*    k );
 
     void findFirstItems( Rim3dView*                          mainOrComparisonView,
                          const std::vector<RiuPickItemInfo>& pickItemInfos,

ApplicationCode/UserInterface/RiuWellPathComponentPlotItem.cpp

@@ -474,8 +474,12 @@ void RiuWellPathComponentPlotItem::addColumnFeature( double         startX,
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
-QwtPlotItem* RiuWellPathComponentPlotItem::createColumnShape(
+QwtPlotItem* RiuWellPathComponentPlotItem::createColumnShape( double         startX,
-    double startX, double endX, double startDepth, double endDepth, cvf::Color4f baseColor, Qt::BrushStyle brushStyle )
+                                                              double         endX,
+                                                              double         startDepth,
+                                                              double         endDepth,
+                                                              cvf::Color4f   baseColor,
+                                                              Qt::BrushStyle brushStyle )
 {
     QwtPlotShapeItem* columnShape = new QwtPlotShapeItem( label() );
     QPolygonF         polygon;