diff --git a/src/engine.c b/src/engine.c
index ba0192b40f20bc6e05a70266d7f750b05b2911b0..3508784350bbf30ed4c45c74b4bf15332ca405ea 100644
--- a/src/engine.c
+++ b/src/engine.c
@@ -4104,9 +4104,14 @@ void engine_barrier(struct engine *e) {
 }
 
 /**
- * @brief Mapping function to collect the data from the kick.
+ * @brief Recursive function gathering end-of-step data.
  *
- * @param c A super-cell.
+ * We recurse until we encounter a timestep or time-step MPI recv task
+ * as the values will have been set at that level. We then bring these
+ * values upwards.
+ *
+ * @param c The #cell to recurse into.
+ * @param e The #engine.
  */
 void engine_collect_end_of_step_recurse(struct cell *c,
                                         const struct engine *e) {
@@ -4165,6 +4170,17 @@ void engine_collect_end_of_step_recurse(struct cell *c,
   c->s_updated = s_updated;
 }
 
+/**
+ * @brief Mapping function to collect the data from the end of the step
+ *
+ * This function will call a recursive function on all the top-level cells
+ * to collect the information we are after.
+ *
+ * @param map_data The list of cells with tasks on this node.
+ * @param num_elements The number of elements in the list this thread will work
+ * on.
+ * @param extra_data The #engine.
+ */
 void engine_collect_end_of_step_mapper(void *map_data, int num_elements,
                                        void *extra_data) {
 
diff --git a/src/multipole.h b/src/multipole.h
index 1525ee57a9b3373c892cc603c793c44a40675a8f..41839b932716c5631bfe5354190c40eb6ab96a3f 100644
--- a/src/multipole.h
+++ b/src/multipole.h
@@ -1725,39 +1725,35 @@ INLINE static void gravity_M2L_apply(
   const float D_112 = pot->D_112;
 
   /* Compute 4th order field tensor terms (addition to rank 0) */
-  l_b->F_000 += M_004 * D_004 + M_013 * D_013 + M_022 * D_022 +
-                M_031 * D_031 + M_040 * D_040 + M_103 * D_103 +
-                M_112 * D_112 + M_121 * D_121 + M_130 * D_130 +
-                M_202 * D_202 + M_211 * D_211 + M_220 * D_220 +
+  l_b->F_000 += M_004 * D_004 + M_013 * D_013 + M_022 * D_022 + M_031 * D_031 +
+                M_040 * D_040 + M_103 * D_103 + M_112 * D_112 + M_121 * D_121 +
+                M_130 * D_130 + M_202 * D_202 + M_211 * D_211 + M_220 * D_220 +
                 M_301 * D_301 + M_310 * D_310 + M_400 * D_400;
 
   /* Compute 4th order field tensor terms (addition to rank 1) */
-  l_b->F_001 += M_003 * D_004 + M_012 * D_013 + M_021 * D_022 +
-                M_030 * D_031 + M_102 * D_103 + M_111 * D_112 +
-                M_120 * D_121 + M_201 * D_202 + M_210 * D_211 +
-                M_300 * D_301;
-  l_b->F_010 += M_003 * D_013 + M_012 * D_022 + M_021 * D_031 +
-                M_030 * D_040 + M_102 * D_112 + M_111 * D_121 +
-                M_120 * D_130 + M_201 * D_211 + M_210 * D_220 +
-                M_300 * D_310;
-  l_b->F_100 += M_003 * D_103 + M_012 * D_112 + M_021 * D_121 +
-                M_030 * D_130 + M_102 * D_202 + M_111 * D_211 +
-                M_120 * D_220 + M_201 * D_301 + M_210 * D_310 +
-                M_300 * D_400;
+  l_b->F_001 += M_003 * D_004 + M_012 * D_013 + M_021 * D_022 + M_030 * D_031 +
+                M_102 * D_103 + M_111 * D_112 + M_120 * D_121 + M_201 * D_202 +
+                M_210 * D_211 + M_300 * D_301;
+  l_b->F_010 += M_003 * D_013 + M_012 * D_022 + M_021 * D_031 + M_030 * D_040 +
+                M_102 * D_112 + M_111 * D_121 + M_120 * D_130 + M_201 * D_211 +
+                M_210 * D_220 + M_300 * D_310;
+  l_b->F_100 += M_003 * D_103 + M_012 * D_112 + M_021 * D_121 + M_030 * D_130 +
+                M_102 * D_202 + M_111 * D_211 + M_120 * D_220 + M_201 * D_301 +
+                M_210 * D_310 + M_300 * D_400;
 
   /* Compute 4th order field tensor terms (addition to rank 2) */
-  l_b->F_002 += M_002 * D_004 + M_011 * D_013 + M_020 * D_022 +
-                M_101 * D_103 + M_110 * D_112 + M_200 * D_202;
-  l_b->F_011 += M_002 * D_013 + M_011 * D_022 + M_020 * D_031 +
-                M_101 * D_112 + M_110 * D_121 + M_200 * D_211;
-  l_b->F_020 += M_002 * D_022 + M_011 * D_031 + M_020 * D_040 +
-                M_101 * D_121 + M_110 * D_130 + M_200 * D_220;
-  l_b->F_101 += M_002 * D_103 + M_011 * D_112 + M_020 * D_121 +
-                M_101 * D_202 + M_110 * D_211 + M_200 * D_301;
-  l_b->F_110 += M_002 * D_112 + M_011 * D_121 + M_020 * D_130 +
-                M_101 * D_211 + M_110 * D_220 + M_200 * D_310;
-  l_b->F_200 += M_002 * D_202 + M_011 * D_211 + M_020 * D_220 +
-                M_101 * D_301 + M_110 * D_310 + M_200 * D_400;
+  l_b->F_002 += M_002 * D_004 + M_011 * D_013 + M_020 * D_022 + M_101 * D_103 +
+                M_110 * D_112 + M_200 * D_202;
+  l_b->F_011 += M_002 * D_013 + M_011 * D_022 + M_020 * D_031 + M_101 * D_112 +
+                M_110 * D_121 + M_200 * D_211;
+  l_b->F_020 += M_002 * D_022 + M_011 * D_031 + M_020 * D_040 + M_101 * D_121 +
+                M_110 * D_130 + M_200 * D_220;
+  l_b->F_101 += M_002 * D_103 + M_011 * D_112 + M_020 * D_121 + M_101 * D_202 +
+                M_110 * D_211 + M_200 * D_301;
+  l_b->F_110 += M_002 * D_112 + M_011 * D_121 + M_020 * D_130 + M_101 * D_211 +
+                M_110 * D_220 + M_200 * D_310;
+  l_b->F_200 += M_002 * D_202 + M_011 * D_211 + M_020 * D_220 + M_101 * D_301 +
+                M_110 * D_310 + M_200 * D_400;
 
   /* Compute 4th order field tensor terms (addition to rank 3) */
   l_b->F_003 += M_001 * D_004 + M_010 * D_013 + M_100 * D_103;
@@ -1836,78 +1832,68 @@ INLINE static void gravity_M2L_apply(
   const float D_113 = pot->D_113;
 
   /* Compute 5th order field tensor terms (addition to rank 0) */
-  l_b->F_000 += M_005 * D_005 + M_014 * D_014 + M_023 * D_023 +
-                M_032 * D_032 + M_041 * D_041 + M_050 * D_050 +
-                M_104 * D_104 + M_113 * D_113 + M_122 * D_122 +
-                M_131 * D_131 + M_140 * D_140 + M_203 * D_203 +
-                M_212 * D_212 + M_221 * D_221 + M_230 * D_230 +
-                M_302 * D_302 + M_311 * D_311 + M_320 * D_320 +
-                M_401 * D_401 + M_410 * D_410 + M_500 * D_500;
+  l_b->F_000 += M_005 * D_005 + M_014 * D_014 + M_023 * D_023 + M_032 * D_032 +
+                M_041 * D_041 + M_050 * D_050 + M_104 * D_104 + M_113 * D_113 +
+                M_122 * D_122 + M_131 * D_131 + M_140 * D_140 + M_203 * D_203 +
+                M_212 * D_212 + M_221 * D_221 + M_230 * D_230 + M_302 * D_302 +
+                M_311 * D_311 + M_320 * D_320 + M_401 * D_401 + M_410 * D_410 +
+                M_500 * D_500;
 
   /* Compute 5th order field tensor terms (addition to rank 1) */
-  l_b->F_001 += M_004 * D_005 + M_013 * D_014 + M_022 * D_023 +
-                M_031 * D_032 + M_040 * D_041 + M_103 * D_104 +
-                M_112 * D_113 + M_121 * D_122 + M_130 * D_131 +
-                M_202 * D_203 + M_211 * D_212 + M_220 * D_221 +
+  l_b->F_001 += M_004 * D_005 + M_013 * D_014 + M_022 * D_023 + M_031 * D_032 +
+                M_040 * D_041 + M_103 * D_104 + M_112 * D_113 + M_121 * D_122 +
+                M_130 * D_131 + M_202 * D_203 + M_211 * D_212 + M_220 * D_221 +
                 M_301 * D_302 + M_310 * D_311 + M_400 * D_401;
-  l_b->F_010 += M_004 * D_014 + M_013 * D_023 + M_022 * D_032 +
-                M_031 * D_041 + M_040 * D_050 + M_103 * D_113 +
-                M_112 * D_122 + M_121 * D_131 + M_130 * D_140 +
-                M_202 * D_212 + M_211 * D_221 + M_220 * D_230 +
+  l_b->F_010 += M_004 * D_014 + M_013 * D_023 + M_022 * D_032 + M_031 * D_041 +
+                M_040 * D_050 + M_103 * D_113 + M_112 * D_122 + M_121 * D_131 +
+                M_130 * D_140 + M_202 * D_212 + M_211 * D_221 + M_220 * D_230 +
                 M_301 * D_311 + M_310 * D_320 + M_400 * D_410;
-  l_b->F_100 += M_004 * D_104 + M_013 * D_113 + M_022 * D_122 +
-                M_031 * D_131 + M_040 * D_140 + M_103 * D_203 +
-                M_112 * D_212 + M_121 * D_221 + M_130 * D_230 +
-                M_202 * D_302 + M_211 * D_311 + M_220 * D_320 +
+  l_b->F_100 += M_004 * D_104 + M_013 * D_113 + M_022 * D_122 + M_031 * D_131 +
+                M_040 * D_140 + M_103 * D_203 + M_112 * D_212 + M_121 * D_221 +
+                M_130 * D_230 + M_202 * D_302 + M_211 * D_311 + M_220 * D_320 +
                 M_301 * D_401 + M_310 * D_410 + M_400 * D_500;
 
   /* Compute 5th order field tensor terms (addition to rank 2) */
-  l_b->F_002 += M_003 * D_005 + M_012 * D_014 + M_021 * D_023 +
-                M_030 * D_032 + M_102 * D_104 + M_111 * D_113 +
-                M_120 * D_122 + M_201 * D_203 + M_210 * D_212 +
-                M_300 * D_302;
-  l_b->F_011 += M_003 * D_014 + M_012 * D_023 + M_021 * D_032 +
-                M_030 * D_041 + M_102 * D_113 + M_111 * D_122 +
-                M_120 * D_131 + M_201 * D_212 + M_210 * D_221 +
-                M_300 * D_311;
-  l_b->F_020 += M_003 * D_023 + M_012 * D_032 + M_021 * D_041 +
-                M_030 * D_050 + M_102 * D_122 + M_111 * D_131 +
-                M_120 * D_140 + M_201 * D_221 + M_210 * D_230 +
-                M_300 * D_320;
-  l_b->F_101 += M_003 * D_104 + M_012 * D_113 + M_021 * D_122 +
-                M_030 * D_131 + M_102 * D_203 + M_111 * D_212 +
-                M_120 * D_221 + M_201 * D_302 + M_210 * D_311 +
-                M_300 * D_401;
-  l_b->F_110 += M_003 * D_113 + M_012 * D_122 + M_021 * D_131 +
-                M_030 * D_140 + M_102 * D_212 + M_111 * D_221 +
-                M_120 * D_230 + M_201 * D_311 + M_210 * D_320 +
-                M_300 * D_410;
-  l_b->F_200 += M_003 * D_203 + M_012 * D_212 + M_021 * D_221 +
-                M_030 * D_230 + M_102 * D_302 + M_111 * D_311 +
-                M_120 * D_320 + M_201 * D_401 + M_210 * D_410 +
-                M_300 * D_500;
+  l_b->F_002 += M_003 * D_005 + M_012 * D_014 + M_021 * D_023 + M_030 * D_032 +
+                M_102 * D_104 + M_111 * D_113 + M_120 * D_122 + M_201 * D_203 +
+                M_210 * D_212 + M_300 * D_302;
+  l_b->F_011 += M_003 * D_014 + M_012 * D_023 + M_021 * D_032 + M_030 * D_041 +
+                M_102 * D_113 + M_111 * D_122 + M_120 * D_131 + M_201 * D_212 +
+                M_210 * D_221 + M_300 * D_311;
+  l_b->F_020 += M_003 * D_023 + M_012 * D_032 + M_021 * D_041 + M_030 * D_050 +
+                M_102 * D_122 + M_111 * D_131 + M_120 * D_140 + M_201 * D_221 +
+                M_210 * D_230 + M_300 * D_320;
+  l_b->F_101 += M_003 * D_104 + M_012 * D_113 + M_021 * D_122 + M_030 * D_131 +
+                M_102 * D_203 + M_111 * D_212 + M_120 * D_221 + M_201 * D_302 +
+                M_210 * D_311 + M_300 * D_401;
+  l_b->F_110 += M_003 * D_113 + M_012 * D_122 + M_021 * D_131 + M_030 * D_140 +
+                M_102 * D_212 + M_111 * D_221 + M_120 * D_230 + M_201 * D_311 +
+                M_210 * D_320 + M_300 * D_410;
+  l_b->F_200 += M_003 * D_203 + M_012 * D_212 + M_021 * D_221 + M_030 * D_230 +
+                M_102 * D_302 + M_111 * D_311 + M_120 * D_320 + M_201 * D_401 +
+                M_210 * D_410 + M_300 * D_500;
 
   /* Compute 5th order field tensor terms (addition to rank 3) */
-  l_b->F_003 += M_002 * D_005 + M_011 * D_014 + M_020 * D_023 +
-                M_101 * D_104 + M_110 * D_113 + M_200 * D_203;
-  l_b->F_012 += M_002 * D_014 + M_011 * D_023 + M_020 * D_032 +
-                M_101 * D_113 + M_110 * D_122 + M_200 * D_212;
-  l_b->F_021 += M_002 * D_023 + M_011 * D_032 + M_020 * D_041 +
-                M_101 * D_122 + M_110 * D_131 + M_200 * D_221;
-  l_b->F_030 += M_002 * D_032 + M_011 * D_041 + M_020 * D_050 +
-                M_101 * D_131 + M_110 * D_140 + M_200 * D_230;
-  l_b->F_102 += M_002 * D_104 + M_011 * D_113 + M_020 * D_122 +
-                M_101 * D_203 + M_110 * D_212 + M_200 * D_302;
-  l_b->F_111 += M_002 * D_113 + M_011 * D_122 + M_020 * D_131 +
-                M_101 * D_212 + M_110 * D_221 + M_200 * D_311;
-  l_b->F_120 += M_002 * D_122 + M_011 * D_131 + M_020 * D_140 +
-                M_101 * D_221 + M_110 * D_230 + M_200 * D_320;
-  l_b->F_201 += M_002 * D_203 + M_011 * D_212 + M_020 * D_221 +
-                M_101 * D_302 + M_110 * D_311 + M_200 * D_401;
-  l_b->F_210 += M_002 * D_212 + M_011 * D_221 + M_020 * D_230 +
-                M_101 * D_311 + M_110 * D_320 + M_200 * D_410;
-  l_b->F_300 += M_002 * D_302 + M_011 * D_311 + M_020 * D_320 +
-                M_101 * D_401 + M_110 * D_410 + M_200 * D_500;
+  l_b->F_003 += M_002 * D_005 + M_011 * D_014 + M_020 * D_023 + M_101 * D_104 +
+                M_110 * D_113 + M_200 * D_203;
+  l_b->F_012 += M_002 * D_014 + M_011 * D_023 + M_020 * D_032 + M_101 * D_113 +
+                M_110 * D_122 + M_200 * D_212;
+  l_b->F_021 += M_002 * D_023 + M_011 * D_032 + M_020 * D_041 + M_101 * D_122 +
+                M_110 * D_131 + M_200 * D_221;
+  l_b->F_030 += M_002 * D_032 + M_011 * D_041 + M_020 * D_050 + M_101 * D_131 +
+                M_110 * D_140 + M_200 * D_230;
+  l_b->F_102 += M_002 * D_104 + M_011 * D_113 + M_020 * D_122 + M_101 * D_203 +
+                M_110 * D_212 + M_200 * D_302;
+  l_b->F_111 += M_002 * D_113 + M_011 * D_122 + M_020 * D_131 + M_101 * D_212 +
+                M_110 * D_221 + M_200 * D_311;
+  l_b->F_120 += M_002 * D_122 + M_011 * D_131 + M_020 * D_140 + M_101 * D_221 +
+                M_110 * D_230 + M_200 * D_320;
+  l_b->F_201 += M_002 * D_203 + M_011 * D_212 + M_020 * D_221 + M_101 * D_302 +
+                M_110 * D_311 + M_200 * D_401;
+  l_b->F_210 += M_002 * D_212 + M_011 * D_221 + M_020 * D_230 + M_101 * D_311 +
+                M_110 * D_320 + M_200 * D_410;
+  l_b->F_300 += M_002 * D_302 + M_011 * D_311 + M_020 * D_320 + M_101 * D_401 +
+                M_110 * D_410 + M_200 * D_500;
 
   /* Compute 5th order field tensor terms (addition to rank 4) */
   l_b->F_004 += M_001 * D_005 + M_010 * D_014 + M_100 * D_104;
diff --git a/tests/testGravityDerivatives.c b/tests/testGravityDerivatives.c
index 125cbc70815ae14056604e79a5616ac20393b650..f31967de7075bccfb2c7fb19c1ba262aa12da54f 100644
--- a/tests/testGravityDerivatives.c
+++ b/tests/testGravityDerivatives.c
@@ -959,7 +959,7 @@ int main(int argc, char* argv[]) {
 
     /* Compute all derivatives */
     struct potential_derivatives_M2L pot;
-    compute_potential_derivatives_M2L(dx, dy, dz, r2, r_inv, eps, eps_inv,
+    potential_derivatives_compute_M2L(dx, dy, dz, r2, r_inv, eps, eps_inv,
                                       periodic, r_s_inv, &pot);
 
     /* Minimal value we care about */
diff --git a/tests/testPotentialPair.c b/tests/testPotentialPair.c
index 380d1fc979f129d46b08306d759eae3ff2739195..12845bea9c44991ff615fbbf4c74dbb3b1a33520 100644
--- a/tests/testPotentialPair.c
+++ b/tests/testPotentialPair.c
@@ -106,6 +106,7 @@ int main(int argc, char *argv[]) {
   e.time = 0.1f;
   e.ti_current = 8;
   e.time_base = 1e-10;
+  e.nodeID = 0;
 
   struct space s;
   s.periodic = 0;
@@ -141,6 +142,7 @@ int main(int argc, char *argv[]) {
   bzero(&ci, sizeof(struct cell));
   bzero(&cj, sizeof(struct cell));
 
+  ci.nodeID = 0;
   ci.width[0] = 1.;
   ci.width[1] = 1.;
   ci.width[2] = 1.;
@@ -153,6 +155,7 @@ int main(int argc, char *argv[]) {
   ci.ti_gravity_end_min = 8;
   ci.ti_gravity_end_max = 8;
 
+  cj.nodeID = 0;
   cj.width[0] = 1.;
   cj.width[1] = 1.;
   cj.width[2] = 1.;
@@ -238,10 +241,11 @@ int main(int argc, char *argv[]) {
 
     double acc_true =
         acceleration(ci.gparts[0].mass, gp->x[0] - gp2->x[0], epsilon, rlr);
-    check_value(gp->a_grav[0], acc_true, "acceleration");
 
     /* message("x=%e f=%e f_true=%e pot=%e pot_true=%e", gp->x[0] - gp2->x[0],
-     *         gp->a_grav[0], acc_true, gp->potential, pot_true); */
+       gp->a_grav[0], acc_true, gp->potential, pot_true); */
+
+    check_value(gp->a_grav[0], acc_true, "acceleration");
   }
 
   message("\n\t\t P-P interactions all good\n");