Apply clang-format

Author: fsimonis

elastic-tube-1d/fluid-cpp/src/FluidComputeSolution.cpp

@@ -3,22 +3,27 @@
 #include <cmath>
 #include <iomanip>
 #include <iostream>
-#include <vector>
 #include <numeric>
+#include <vector>
 
 using std::sin;
 using std::sqrt;
 
 // Simplifies strided access on a 1d buffer
-template<class T>
+template <class T>
 class StridedAccess {
-  public:
-    StridedAccess(T*first, int stride) : first(first), stride(stride) {};
-    // This accessor allows for row-major access
-    T& operator()(int i, int j) { return first[j*stride+i]; }
-  private:
-    T*first;
-    int stride;
+public:
+  StridedAccess(T *first, int stride)
+      : first(first), stride(stride){};
+  // This accessor allows for row-major access
+  T &operator()(int i, int j)
+  {
+    return first[j * stride + i];
+  }
+
+private:
+  T * first;
+  int stride;
 };
 
 extern "C" {
@@ -35,16 +40,16 @@ void dgesv_(
 
 /* Function for fluid_nl i.e. non-linear */
 int fluidComputeSolutionSerial(
-    double const * const velocity_old,
-    double const * const pressure_old,
-    double const * const crossSectionLength_old,
-    double const * const crossSectionLength,
-    double  t,
-    int     N,
-    double  kappa,
-    double  tau,
-    double * velocity,
-    double * pressure)
+    double const *const velocity_old,
+    double const *const pressure_old,
+    double const *const crossSectionLength_old,
+    double const *const crossSectionLength,
+    double              t,
+    int                 N,
+    double              kappa,
+    double              tau,
+    double *            velocity,
+    double *            pressure)
 {
   const double PI = 3.141592653589793;
 
@@ -59,67 +64,52 @@ int fluidComputeSolutionSerial(
 
   // Used as Ax = b
   // i.e. LHS*x = Res
-  std::vector<double> Res(2 * N + 2);
-  std::vector<double> LHS_buffer(std::pow(2*N + 2, 2));
-  StridedAccess<double> LHS(LHS_buffer.data(), 2* N + 2);
+  std::vector<double>   Res(2 * N + 2);
+  std::vector<double>   LHS_buffer(std::pow(2 * N + 2, 2));
+  StridedAccess<double> LHS(LHS_buffer.data(), 2 * N + 2);
 
   /* LAPACK Variables */
-  int nlhs = (2 * N + 2);
-  int nrhs = 1;
+  int              nlhs = (2 * N + 2);
+  int              nrhs = 1;
   std::vector<int> ipiv(nlhs);
 
   /* Stabilization Intensity */
   const double alpha = 0.0; //(N * kappa * tau) / (N * tau + 1);
-  const double L = 10.0;
-  const double dx = L / kappa; // 1.0 / (N * kappa);
+  const double L     = 10.0;
+  const double dx    = L / kappa; // 1.0 / (N * kappa);
 
   // k is the iteration counter
-  for(int k = 1; ; ++k) {
+  for (int k = 1;; ++k) {
     std::fill(Res.begin(), Res.end(), 0.0);
 
     for (int i = 1; i < N; i++) {
-      /* Momentum */ 
+      /* Momentum */
       Res[i] = (velocity_old[i] * crossSectionLength_old[i] - velocity[i] * crossSectionLength[i]) * dx / tau;
 
-      Res[i] += 0.25 * (- crossSectionLength[i + 1] * velocity[i] * velocity[i + 1]
-                        - crossSectionLength[i] * velocity[i] * velocity[i + 1]);
+      Res[i] += 0.25 * (-crossSectionLength[i + 1] * velocity[i] * velocity[i + 1] - crossSectionLength[i] * velocity[i] * velocity[i + 1]);
 
-      Res[i] += 0.25 * (- crossSectionLength[i + 1] * velocity[i] * velocity[i]
-                        - crossSectionLength[i] * velocity[i] * velocity[i]
-                        + crossSectionLength[i] * velocity[i - 1] * velocity[i] 
-                        + crossSectionLength[i - 1] * velocity[i - 1] * velocity[i]);
+      Res[i] += 0.25 * (-crossSectionLength[i + 1] * velocity[i] * velocity[i] - crossSectionLength[i] * velocity[i] * velocity[i] + crossSectionLength[i] * velocity[i - 1] * velocity[i] + crossSectionLength[i - 1] * velocity[i - 1] * velocity[i]);
 
-      Res[i] += 0.25 * (+ crossSectionLength[i - 1] * velocity[i - 1] * velocity[i - 1]
-                        + crossSectionLength[i] * velocity[i - 1] * velocity[i - 1]);
+      Res[i] += 0.25 * (+crossSectionLength[i - 1] * velocity[i - 1] * velocity[i - 1] + crossSectionLength[i] * velocity[i - 1] * velocity[i - 1]);
 
-      Res[i] += 0.25*(+ crossSectionLength[i - 1] * pressure[i - 1]
-                      + crossSectionLength[i]     * pressure[i - 1]
-                      - crossSectionLength[i - 1] * pressure[i]
-                      + crossSectionLength[i + 1] * pressure[i]
-                      - crossSectionLength[i]     * pressure[i + 1]
-                      - crossSectionLength[i + 1] * pressure[i + 1]);
+      Res[i] += 0.25 * (+crossSectionLength[i - 1] * pressure[i - 1] + crossSectionLength[i] * pressure[i - 1] - crossSectionLength[i - 1] * pressure[i] + crossSectionLength[i + 1] * pressure[i] - crossSectionLength[i] * pressure[i + 1] - crossSectionLength[i + 1] * pressure[i + 1]);
 
       /* Continuity */
       Res[i + N + 1] = (crossSectionLength_old[i] - crossSectionLength[i]) * dx / tau;
-      Res[i + N + 1] += 0.25*(+ crossSectionLength[i - 1] * velocity[i - 1]
-                              + crossSectionLength[i]     * velocity[i - 1]
-                              + crossSectionLength[i - 1] * velocity[i]
-                              - crossSectionLength[i + 1] * velocity[i]
-                              - crossSectionLength[i]     * velocity[i + 1]
-                              - crossSectionLength[i + 1] * velocity[i + 1]);
+      Res[i + N + 1] += 0.25 * (+crossSectionLength[i - 1] * velocity[i - 1] + crossSectionLength[i] * velocity[i - 1] + crossSectionLength[i - 1] * velocity[i] - crossSectionLength[i + 1] * velocity[i] - crossSectionLength[i] * velocity[i + 1] - crossSectionLength[i + 1] * velocity[i + 1]);
 
       Res[i + N + 1] += alpha * (pressure[i - 1] - 2 * pressure[i] + pressure[i + 1]);
     }
 
     /* Boundary */
 
     /* Velocity Inlet is prescribed */
-    const double u0 = 10.0;
-    const double ampl = 3.0;
-    const double frequency = 10.0;
-    const double t_shift = 0.0;
+    const double u0          = 10.0;
+    const double ampl        = 3.0;
+    const double frequency   = 10.0;
+    const double t_shift     = 0.0;
     const double velocity_in = u0 + ampl * sin(frequency * (t + t_shift) * PI);
-    Res[0] = velocity_in - velocity[0];
+    Res[0]                   = velocity_in - velocity[0];
 
     /* Pressure Inlet is linearly interpolated */
     Res[N + 1] = -pressure[0] + 2 * pressure[1] - pressure[2];
@@ -129,17 +119,15 @@ int fluidComputeSolutionSerial(
 
     /* Pressure Outlet is "non-reflecting" */
     const double tmp2 = sqrt(c_mk2 - pressure_old[N] / 2) - (velocity[N] - velocity_old[N]) / 4;
-    Res[2 * N + 1] = -pressure[N] + 2 * (c_mk2 - std::pow(tmp2, 2));
+    Res[2 * N + 1]    = -pressure[N] + 2 * (c_mk2 - std::pow(tmp2, 2));
 
     // compute norm of residual
     const double norm_1 = std::sqrt(
-        std::inner_product(Res.begin(), Res.end(), Res.begin(), 0.0)
-        );
+        std::inner_product(Res.begin(), Res.end(), Res.begin(), 0.0));
 
     const double norm_2 = std::sqrt(
         std::inner_product(pressure, pressure + chunkLength, pressure, 0.0) +
-        std::inner_product(velocity, velocity + chunkLength, velocity, 0.0)
-        );
+        std::inner_product(velocity, velocity + chunkLength, velocity, 0.0));
     const double norm = norm_1 / norm_2;
 
     // NOTE tolerance is 1e-10 and max iterations is 1000 in python
@@ -153,34 +141,25 @@ int fluidComputeSolutionSerial(
 
     for (int i = 1; i < N; i++) {
       // Momentum, Velocity
-      LHS(i, i - 1) +=0.25*(-2 * crossSectionLength[i - 1] * velocity[i - 1]
-                            -2 * crossSectionLength[i]     * velocity[i - 1]
-                            -    crossSectionLength[i]     * velocity[i]
-                            -    crossSectionLength[i - 1] * velocity[i]);
-
-      LHS(i, i)     += crossSectionLength[i] * dx / tau;
-      LHS(i, i)     +=  0.25 * (+    crossSectionLength[i + 1] * velocity[i + 1]
-                                +    crossSectionLength[i]     * velocity[i + 1]
-                                +2 * crossSectionLength[i + 1] * velocity[i] 
-                                +2 * crossSectionLength[i]     * velocity[i]
-                                -    crossSectionLength[i]     * velocity[i - 1]
-                                -    crossSectionLength[i - 1] * velocity[i - 1]);
-      LHS(i, i + 1) +=  0.25 * (+ crossSectionLength[i + 1] * velocity[i]    
-                                + crossSectionLength[i]     * velocity[i]);
+      LHS(i, i - 1) += 0.25 * (-2 * crossSectionLength[i - 1] * velocity[i - 1] - 2 * crossSectionLength[i] * velocity[i - 1] - crossSectionLength[i] * velocity[i] - crossSectionLength[i - 1] * velocity[i]);
+
+      LHS(i, i) += crossSectionLength[i] * dx / tau;
+      LHS(i, i) += 0.25 * (+crossSectionLength[i + 1] * velocity[i + 1] + crossSectionLength[i] * velocity[i + 1] + 2 * crossSectionLength[i + 1] * velocity[i] + 2 * crossSectionLength[i] * velocity[i] - crossSectionLength[i] * velocity[i - 1] - crossSectionLength[i - 1] * velocity[i - 1]);
+      LHS(i, i + 1) += 0.25 * (+crossSectionLength[i + 1] * velocity[i] + crossSectionLength[i] * velocity[i]);
 
       // Momentum, Pressure
       LHS(i, N + 1 + i - 1) += -0.25 * crossSectionLength[i - 1] - 0.25 * crossSectionLength[i];
-      LHS(i, N + 1 + i)     +=  0.25 * crossSectionLength[i - 1] - 0.25 * crossSectionLength[i + 1];
-      LHS(i, N + 1 + i + 1) +=  0.25 * crossSectionLength[i]     + 0.25 * crossSectionLength[i + 1];
+      LHS(i, N + 1 + i) += 0.25 * crossSectionLength[i - 1] - 0.25 * crossSectionLength[i + 1];
+      LHS(i, N + 1 + i + 1) += 0.25 * crossSectionLength[i] + 0.25 * crossSectionLength[i + 1];
 
       // Continuity, Velocity
       LHS(i + N + 1, i - 1) += -0.25 * crossSectionLength[i - 1] - 0.25 * crossSectionLength[i];
-      LHS(i + N + 1, i)     += -0.25 * crossSectionLength[i - 1] + 0.25 * crossSectionLength[i + 1];
-      LHS(i + N + 1, i + 1) +=  0.25 * crossSectionLength[i]     + 0.25 * crossSectionLength[i + 1];
+      LHS(i + N + 1, i) += -0.25 * crossSectionLength[i - 1] + 0.25 * crossSectionLength[i + 1];
+      LHS(i + N + 1, i + 1) += 0.25 * crossSectionLength[i] + 0.25 * crossSectionLength[i + 1];
 
       // Continuity, Pressure
       LHS(i + N + 1, N + 1 + i - 1) -= alpha;
-      LHS(i + N + 1, N + 1 + i)     += 2 * alpha;
+      LHS(i + N + 1, N + 1 + i) += 2 * alpha;
       LHS(i + N + 1, N + 1 + i + 1) -= alpha;
     }
 

elastic-tube-1d/fluid-cpp/src/FluidComputeSolution.h

@@ -3,13 +3,13 @@
 const double PI = 3.14159265359;
 
 int fluidComputeSolutionSerial(
-    double const * const velocity_old,
-    double const * const pressure_old,
-    double const * const crossSectionLength_old,
-    double const * const crossSectionLength,
-    double  t,
-    int     N,
-    double  kappa,
-    double  tau,
-    double * velocity,
-    double * pressure);
+    double const *const velocity_old,
+    double const *const pressure_old,
+    double const *const crossSectionLength_old,
+    double const *const crossSectionLength,
+    double              t,
+    int                 N,
+    double              kappa,
+    double              tau,
+    double *            velocity,
+    double *            pressure);

elastic-tube-1d/fluid-cpp/src/FluidSolver.cpp

@@ -1,9 +1,9 @@
 #include "FluidComputeSolution.h"
 #include "utilities.h"
 
+#include <cmath>
 #include <iostream>
 #include <vector>
-#include <cmath>
 #include "precice/precice.hpp"
 
 using namespace precice;
@@ -19,11 +19,11 @@ int main(int argc, char **argv)
     return -1;
   }
 
-  std::string configFileName(argv[1]);
-  int         domainSize  = 100;  //N
-  int         chunkLength = domainSize + 1;
-  const double kappa      = 100;
-  const double L = 10.0; // tube length
+  std::string  configFileName(argv[1]);
+  int          domainSize  = 100; //N
+  int          chunkLength = domainSize + 1;
+  const double kappa       = 100;
+  const double L           = 10.0; // tube length
 
   const std::string solverName = "Fluid";
 
@@ -32,23 +32,23 @@ int main(int argc, char **argv)
   precice::Participant interface(solverName, configFileName, 0, 1);
   std::cout << "preCICE configured..." << std::endl;
 
-  auto meshName               = "Fluid-Nodes-Mesh";
-  auto pressureName           = "Pressure";
-  auto crossSectionLengthName = "CrossSectionLength";
-  const int dimensions        = interface.getMeshDimensions(meshName);
+  auto      meshName               = "Fluid-Nodes-Mesh";
+  auto      pressureName           = "Pressure";
+  auto      crossSectionLengthName = "CrossSectionLength";
+  const int dimensions             = interface.getMeshDimensions(meshName);
 
-  std::vector<int>    vertexIDs(chunkLength);
+  std::vector<int> vertexIDs(chunkLength);
 
   const double PI = 3.141592653589793;
 
-  const double r0 = 1 / sqrt(PI); // radius of the tube
-  const double a0 = std::pow(r0, 2) * PI; // cross sectional area
-  const double u0 = 10; // mean velocity
-  const double ampl = 3; // amplitude of varying velocity
-  const double frequency = 10; // frequency of variation
-  const double t_shift = 0; // temporal shift of variation
-  const double p0 = 0; // pressure at outlet
-  const double vel_in_0 = u0 + ampl * sin(frequency * (t_shift) * PI);
+  const double r0        = 1 / sqrt(PI);         // radius of the tube
+  const double a0        = std::pow(r0, 2) * PI; // cross sectional area
+  const double u0        = 10;                   // mean velocity
+  const double ampl      = 3;                    // amplitude of varying velocity
+  const double frequency = 10;                   // frequency of variation
+  const double t_shift   = 0;                    // temporal shift of variation
+  const double p0        = 0;                    // pressure at outlet
+  const double vel_in_0  = u0 + ampl * sin(frequency * (t_shift) *PI);
 
   std::vector<double> pressure(chunkLength, p0);
   std::vector<double> pressure_old(pressure);
@@ -58,7 +58,7 @@ int main(int argc, char **argv)
   std::vector<double> velocity_old(velocity);
   std::vector<double> grid(dimensions * chunkLength);
 
-  const double cellwidth =(L / domainSize) ;
+  const double cellwidth = (L / domainSize);
   for (int i = 0; i < chunkLength; i++) {
     for (int d = 0; d < dimensions; d++) {
       if (d == 0) {
@@ -75,7 +75,7 @@ int main(int argc, char **argv)
     interface.writeData(meshName, pressureName, vertexIDs, pressure);
   }
 
-  double t  = 0.0;
+  double t = 0.0;
   std::cout << "Initialize preCICE..." << std::endl;
   interface.initialize();
 
@@ -84,7 +84,7 @@ int main(int argc, char **argv)
   std::copy(crossSectionLength.begin(), crossSectionLength.end(), crossSectionLength_old.begin());
 
   // initialize such that mass conservation is fulfilled
-  for(int i = 0; i < chunkLength; ++i) {
+  for (int i = 0; i < chunkLength; ++i) {
     velocity_old[i] = vel_in_0 * crossSectionLength_old[0] / crossSectionLength_old[i];
   }
 
@@ -95,34 +95,34 @@ int main(int argc, char **argv)
     }
 
     auto dt = interface.getMaxTimeStepSize();
-    
+
     fluidComputeSolutionSerial(
         // values from last time window
         velocity_old.data(), pressure_old.data(), crossSectionLength_old.data(),
         // last received crossSectionLength
         crossSectionLength.data(),
-        t+dt, // used for inlet velocity
-        domainSize, 
-        kappa, 
+        t + dt, // used for inlet velocity
+        domainSize,
+        kappa,
         dt, // tau
         // resulting velocity pressure
         velocity.data(),
         pressure.data());
-    
+
     interface.writeData(meshName, pressureName, vertexIDs, pressure);
-    
+
     interface.advance(dt);
 
-    interface.readData(meshName,crossSectionLengthName, vertexIDs, interface.getMaxTimeStepSize(),  crossSectionLength);
+    interface.readData(meshName, crossSectionLengthName, vertexIDs, interface.getMaxTimeStepSize(), crossSectionLength);
 
     if (interface.requiresReadingCheckpoint()) {
     } else {
       t += dt;
       write_vtk(t, out_counter, outputFilePrefix.c_str(), chunkLength, grid.data(), velocity.data(), pressure.data(), crossSectionLength.data());
       for (int i = 0; i < chunkLength; i++) {
         crossSectionLength_old[i] = crossSectionLength[i];
-        pressure_old[i] = pressure[i];
-        velocity_old[i] = velocity[i];
+        pressure_old[i]           = pressure[i];
+        velocity_old[i]           = velocity[i];
       }
       out_counter++;
     }