uncrustify

Author: rrsettgast

src/common/CArrayWrapper.hpp

@@ -29,7 +29,7 @@ struct CArrayWrapper< T, DIM0 >
 {
   // default constructor
   constexpr CArrayWrapper() = default;
-  
+
   /**
    * @brief Construct a CArrayWrapper from an initializer list.
    *
@@ -54,7 +54,7 @@ struct CArrayWrapper< T, DIM0 >
   /**
    * @brief Copy constructor.
    * @param src The source CArrayWrapper to copy from.
-   */ 
+   */
   constexpr CArrayWrapper( CArrayWrapper const & src )
   {
     for( std::size_t i = 0; i < DIM0; i++ )
@@ -110,7 +110,7 @@ struct CArrayWrapper< T, DIM0, DIM1 >
 {
   // default constructor
   constexpr CArrayWrapper() = default;
-  
+
   /**
    * @brief Copy constructor.
    * @param src The source CArrayWrapper to copy from.
@@ -119,7 +119,7 @@ struct CArrayWrapper< T, DIM0, DIM1 >
   {
     for( std::size_t i = 0; i < DIM0; i++ )
     {
-      for ( std::size_t j = 0; j < DIM1; j++)
+      for( std::size_t j = 0; j < DIM1; j++ )
         data[i][j] = src.data[i][j];
     }
   }

src/common/nonlinearSolvers.hpp

@@ -4,7 +4,7 @@
 #include "DirectSystemSolve.hpp"
 #include <cmath>
 
-namespace hpcReact 
+namespace hpcReact
 {
 
 namespace nonlinearSolvers
@@ -21,12 +21,13 @@ namespace internal
  * @return The Euclidean norm of the vector.
  */
 template< int N >
-HPCREACT_HOST_DEVICE 
-double norm( double const (&r)[N]) 
+HPCREACT_HOST_DEVICE
+double norm( double const (&r)[N] )
 {
-    double sum = 0.0;
-    for ( int i = 0; i < N; ++i ) sum += r[i] * r[i];
-    return ::sqrt( sum );
+  double sum = 0.0;
+  for( int i = 0; i < N; ++i )
+    sum += r[i] * r[i];
+  return ::sqrt( sum );
 }
 
 /**
@@ -37,10 +38,11 @@ double norm( double const (&r)[N])
  * @param dx The second vector, which will be added to the first vector.
  */
 template< int N >
-HPCREACT_HOST_DEVICE 
-void add(double (&x)[N], double const (&dx)[N]) 
+HPCREACT_HOST_DEVICE
+void add( double (& x)[N], double const (&dx)[N] )
 {
-    for (int i = 0; i < N; ++i) x[i] += dx[i];
+  for( int i = 0; i < N; ++i )
+    x[i] += dx[i];
 }
 
 /**
@@ -51,16 +53,17 @@ void add(double (&x)[N], double const (&dx)[N])
  * @param value The scaling factor.
  */
 template< int N >
-HPCREACT_HOST_DEVICE 
-void scale( double (&x)[N], double const value ) 
+HPCREACT_HOST_DEVICE
+void scale( double (& x)[N], double const value )
 {
-    for (int i = 0; i < N; ++i) x[i] *= value;
+  for( int i = 0; i < N; ++i )
+    x[i] *= value;
 }
 
 }
 
 namespace utils
-{   
+{
 // LCOV_EXCL_START
 
 /**
@@ -74,113 +77,115 @@ namespace utils
  */
 template< int N >
 HPCREACT_HOST_DEVICE
-void print(double const (&J)[N][N], double const (&r)[N], double const (&dx)[N])
+void print( double const (&J)[N][N], double const (&r)[N], double const (&dx)[N] )
 {
-    printf("=======================\nJacobian matrix:\n=======================\n");
-    printf("     RowID           ColID                       Value\n");    for ( int i = 0; i < N; ++i )
+  printf( "=======================\nJacobian matrix:\n=======================\n" );
+  printf( "     RowID           ColID                       Value\n" );    for( int i = 0; i < N; ++i )
+  {
+    for( int j = 0; j < N; ++j )
     {
-        for ( int j = 0; j < N; ++j )
-        {
-            printf("%10d%16d%27.16e\n", i, j, J[i][j]);
-        }
+      printf( "%10d%16d%27.16e\n", i, j, J[i][j] );
     }
+  }
 
-    printf("\n=======================\nSystem right-hand side:\n=======================\n");
-    printf("     RowID                       Value\n");
+  printf( "\n=======================\nSystem right-hand side:\n=======================\n" );
+  printf( "     RowID                       Value\n" );
 
-    for ( int i = 0; i < N; ++i )
-    {
-        printf("%10d%27.16e\n", i, r[i]);
-    }
-    
-    printf("\n=======================\nDelta update vector:\n=======================\n");
-    printf("     RowID                       Value\n");
-    
-    for ( int i = 0; i < N; ++i )
-    {
-        printf("%10d%27.16e\n", i, dx[i]);
-    }
+  for( int i = 0; i < N; ++i )
+  {
+    printf( "%10d%27.16e\n", i, r[i] );
+  }
+
+  printf( "\n=======================\nDelta update vector:\n=======================\n" );
+  printf( "     RowID                       Value\n" );
+
+  for( int i = 0; i < N; ++i )
+  {
+    printf( "%10d%27.16e\n", i, dx[i] );
+  }
 }
 // LCOV_EXCL_STOP
 
 }
 
 template< int N,
-          typename REAL_TYPE, 
-          typename ResidualFunc, 
+          typename REAL_TYPE,
+          typename ResidualFunc,
           typename JacobianFunc >
-HPCREACT_HOST_DEVICE 
-void newtonRaphson( REAL_TYPE (&x)[N], 
+HPCREACT_HOST_DEVICE
+void newtonRaphson( REAL_TYPE (& x)[N],
                     ResidualFunc computeResidual,
                     JacobianFunc computeJacobian,
                     int maxIters = 25,
                     double tol = 1e-10 )
 {
-    REAL_TYPE residual[N];
-    REAL_TYPE dx[N];
-    REAL_TYPE jacobian[N][N];
+  REAL_TYPE residual[N];
+  REAL_TYPE dx[N];
+  REAL_TYPE jacobian[N][N];
 
-    for ( int iter = 0; iter < maxIters; ++iter ) 
-    {
-        computeResidual( x, residual );
+  for( int iter = 0; iter < maxIters; ++iter )
+  {
+    computeResidual( x, residual );
 
-        if ( internal::norm< N >( residual ) < tol ) return;
+    if( internal::norm< N >( residual ) < tol )
+      return;
 
-        computeJacobian( x, jacobian );
+    computeJacobian( x, jacobian );
 
-        solveNxN_pivoted< REAL_TYPE, N >( jacobian, residual, dx );
+    solveNxN_pivoted< REAL_TYPE, N >( jacobian, residual, dx );
 
-        internal::add< N >( x, dx );
-    }
+    internal::add< N >( x, dx );
+  }
 }
 
 template< int N,
-          typename REAL_TYPE, 
-          typename FUNCTION_TYPE > 
-HPCREACT_HOST_DEVICE 
-bool newtonRaphson( REAL_TYPE (&x)[N], 
+          typename REAL_TYPE,
+          typename FUNCTION_TYPE >
+HPCREACT_HOST_DEVICE
+bool newtonRaphson( REAL_TYPE (& x)[N],
                     FUNCTION_TYPE computeResidualAndJacobian,
                     int maxIters = 12,
                     double tol = 1e-10,
                     bool const do_print = false )
 {
-    REAL_TYPE residual[N]{};
-    REAL_TYPE dx[N]{};
-    REAL_TYPE jacobian[N][N]{};
-    bool isConverged = false;
+  REAL_TYPE residual[N]{};
+  REAL_TYPE dx[N]{};
+  REAL_TYPE jacobian[N][N]{};
+  bool isConverged = false;
+
+  for( int iter = 0; iter < maxIters; ++iter )
+  {
+    computeResidualAndJacobian( x, residual, jacobian );
+
+    double const norm = internal::norm< N >( residual );
+
+    printf( "--Iter %d: Residual norm = %.12e\n", iter, norm );
 
-    for ( int iter = 0; iter < maxIters; ++iter ) 
+    if( norm < tol )
     {
-        computeResidualAndJacobian( x, residual, jacobian );
-
-        double const norm = internal::norm< N >( residual );
-
-        printf( "--Iter %d: Residual norm = %.12e\n", iter, norm );
-
-        if ( norm < tol ) {
-            printf( "--Converged.\n" );
-            isConverged = true;
-            break;
-        }
-        internal::scale<N>( residual, -1.0);
-
-        if( do_print )
-        {
-            utils::print( jacobian, residual, dx ); // LCOV_EXCL_LINE
-        }
-       
-        solveNxN_pivoted< REAL_TYPE, N >( jacobian, residual, dx );
-        internal::add< N >( x, dx );
-        
+      printf( "--Converged.\n" );
+      isConverged = true;
+      break;
     }
-    
-    if( !isConverged )
+    internal::scale< N >( residual, -1.0 );
+
+    if( do_print )
     {
-        printf( "--Newton solver error: Max iterations reached without convergence.\n" );
+      utils::print( jacobian, residual, dx ); // LCOV_EXCL_LINE
     }
 
-    return isConverged;
+    solveNxN_pivoted< REAL_TYPE, N >( jacobian, residual, dx );
+    internal::add< N >( x, dx );
+
+  }
+
+  if( !isConverged )
+  {
+    printf( "--Newton solver error: Max iterations reached without convergence.\n" );
+  }
+
+  return isConverged;
 }
 
 }
-}
+}