Update to Google Style

Author: TimGoTheCreator

src/gravity/step.h

@@ -2,107 +2,107 @@
 // it under the terms of the GNU General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
-
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // GNU General Public License for more details.
-
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #pragma once
 #include "../struct/particle.h"
-#include <vector>
-#include "octree.h"
 #include "floatdef.h"
+#include "octree.h"
+#include <vector>
 
-inline void Step(std::vector<Particle>& p, real dt) {
-    if (p.empty()) return;
-
-    real theta = 0.5;
-    real half  = dt * real(0.5);
-
-    auto buildTree = [&](Octree*& root) {
-        // Compute bounding box
-        real minx=+1e30, miny=+1e30, minz=+1e30;
-        real maxx=-1e30, maxy=-1e30, maxz=-1e30;
-
-        for (auto& a : p) {
-            minx = std::min(minx, a.x);
-            miny = std::min(miny, a.y);
-            minz = std::min(minz, a.z);
-            maxx = std::max(maxx, a.x);
-            maxy = std::max(maxy, a.y);
-            maxz = std::max(maxz, a.z);
-        }
-
-        real cx = (minx + maxx) * 0.5;
-        real cy = (miny + maxy) * 0.5;
-        real cz = (minz + maxz) * 0.5;
-        real dx = maxx - minx;      
-        real dy = maxy - miny;
-        real dz = maxz - minz;
+inline void Step(std::vector<Particle> &p, real dt) {
+  if (p.empty())
+    return;
+
+  real theta = 0.5;
+  real half = dt * real(0.5);
+
+  auto buildTree = [&](Octree *&root) {
+    // Compute bounding box
+    real minx = +1e30, miny = +1e30, minz = +1e30;
+    real maxx = -1e30, maxy = -1e30, maxz = -1e30;
+
+    for (auto &a : p) {
+      minx = std::min(minx, a.x);
+      miny = std::min(miny, a.y);
+      minz = std::min(minz, a.z);
+      maxx = std::max(maxx, a.x);
+      maxy = std::max(maxy, a.y);
+      maxz = std::max(maxz, a.z);
+    }
 
-        real size = std::max(dx, std::max(dy, dz)) * real(0.5);
+    real cx = (minx + maxx) * 0.5;
+    real cy = (miny + maxy) * 0.5;
+    real cz = (minz + maxz) * 0.5;
+    real dx = maxx - minx;
+    real dy = maxy - miny;
+    real dz = maxz - minz;
 
-        if (size <= 0) size = 1; // safety
+    real size = std::max(dx, std::max(dy, dz)) * real(0.5);
 
-        root = new Octree(cx, cy, cz, size);
+    if (size <= 0)
+      size = 1; // safety
 
-        for (auto& a : p)
-            root->insert(&a);
+    root = new Octree(cx, cy, cz, size);
 
-        root->computeMass();
-    };
+    for (auto &a : p)
+      root->insert(&a);
 
-    // =========================
-    // First Kick (dt/2)
-    // =========================
-    {
-        Octree* root = nullptr;
-        buildTree(root);
+    root->computeMass();
+  };
 
-        #pragma omp parallel for schedule(static)
-        for (int i = 0; i < (int)p.size(); i++) {
-            real ax = 0, ay = 0, az = 0;
-            bhAccel(root, p[i], theta, ax, ay, az);
+  // =========================
+  // First Kick (dt/2)
+  // =========================
+  {
+    Octree *root = nullptr;
+    buildTree(root);
 
-            p[i].vx += ax * half;
-            p[i].vy += ay * half;
-            p[i].vz += az * half;
-        }
+#pragma omp parallel for schedule(static)
+    for (int i = 0; i < (int)p.size(); i++) {
+      real ax = 0, ay = 0, az = 0;
+      bhAccel(root, p[i], theta, ax, ay, az);
 
-        delete root;
+      p[i].vx += ax * half;
+      p[i].vy += ay * half;
+      p[i].vz += az * half;
     }
 
-    // =========================
-    // Drift (dt)
-    // =========================
-    #pragma omp parallel for schedule(static)
+    delete root;
+  }
+
+// =========================
+// Drift (dt)
+// =========================
+#pragma omp parallel for schedule(static)
+  for (int i = 0; i < (int)p.size(); i++) {
+    p[i].x += p[i].vx * dt;
+    p[i].y += p[i].vy * dt;
+    p[i].z += p[i].vz * dt;
+  }
+
+  // =========================
+  // Second Kick (dt/2)
+  // =========================
+  {
+    Octree *root = nullptr;
+    buildTree(root);
+
+#pragma omp parallel for schedule(static)
     for (int i = 0; i < (int)p.size(); i++) {
-        p[i].x += p[i].vx * dt;
-        p[i].y += p[i].vy * dt;
-        p[i].z += p[i].vz * dt;
-    }
+      real ax = 0, ay = 0, az = 0;
+      bhAccel(root, p[i], theta, ax, ay, az);
 
-    // =========================
-    // Second Kick (dt/2)
-    // =========================
-    {
-        Octree* root = nullptr;
-        buildTree(root);
-
-        #pragma omp parallel for schedule(static)
-        for (int i = 0; i < (int)p.size(); i++) {
-            real ax = 0, ay = 0, az = 0;
-            bhAccel(root, p[i], theta, ax, ay, az);
-
-            p[i].vx += ax * half;
-            p[i].vy += ay * half;
-            p[i].vz += az * half;
-        }
-
-        delete root;
+      p[i].vx += ax * half;
+      p[i].vy += ay * half;
+      p[i].vz += az * half;
     }
+
+    delete root;
+  }
 }