Update step.h

Author: TimGoTheCreator

src/gravity/step.h

@@ -14,95 +14,79 @@
 #include "floatdef.h"
 #include "octree.h"
 #include <vector>
+#include <memory>
+#include <algorithm>
 
 inline void Step(std::vector<Particle> &p, real dt) {
-  if (p.empty())
-    return;
+  if (p.empty()) return;
 
   real theta = 0.5;
   real half = dt * real(0.5);
 
-  auto buildTree = [&](Octree *&root) {
-    // Compute bounding box
+  // Helper lambda that returns a unique_ptr
+  auto buildTree = [&]() -> std::unique_ptr<Octree> {
     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);
+    for (const 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;
+    real size = std::max({maxx - minx, maxy - miny, maxz - minz}) * real(0.5);
 
-    real size = std::max(dx, std::max(dy, dz)) * real(0.5);
+    if (size <= 0) size = 1;
 
-    if (size <= 0)
-      size = 1; // safety
-
-    root = new Octree(cx, cy, cz, size);
+    // Create the owned root
+    auto root = std::make_unique<Octree>(cx, cy, cz, size);
 
     for (auto &a : p)
       root->insert(&a);
 
     root->computeMass();
+    return root; 
   };
 
-  // =========================
-  // First Kick (dt/2)
-  // =========================
+  // --- First Kick (dt/2) ---
   {
-    Octree *root = nullptr;
-    buildTree(root);
+    std::unique_ptr<Octree> root = buildTree();
 
 #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);
+      // Pass the raw pointer via .get() for the traversal
+      bhAccel(root.get(), p[i], theta, ax, ay, az);
 
       p[i].vx += ax * half;
       p[i].vy += ay * half;
       p[i].vz += az * half;
     }
-
-    delete root;
+    // No 'delete root' needed! It happens automatically here.
   }
 
-// =========================
-// Drift (dt)
-// =========================
+  // --- 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)
-  // =========================
+  // --- Second Kick (dt/2) ---
   {
-    Octree *root = nullptr;
-    buildTree(root);
+    std::unique_ptr<Octree> root = buildTree();
 
 #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);
+      bhAccel(root.get(), p[i], theta, ax, ay, az);
 
       p[i].vx += ax * half;
       p[i].vy += ay * half;
       p[i].vz += az * half;
     }
-
-    delete root;
   }
 }